### NDC ###

首先我们先了解一下log4cplus中嵌入诊断上下文（Nested Diagnostic Context），即NDC。对log系统而言，
当输入源可能不止一个，而只有一个输出时，往往需要分辩所要输出消息的来源，比如服务器处理来自不同
客户端的消息时就需要作此判断，NDC可以为交错显示的信息打上一个标记(stamp)， 使得辨认工作看起来
比较容易些，呵呵。这个标记是线程特有的，利用了线程局部存储机制，称为线程私有数据（Thread-specific
 Data，或TSD）。 看了一下源代码，相关定义如下，包括定义、初始化、获取、设置和清除操作：

linux pthread

				
#   define LOG4CPLUS_THREAD_LOCAL_TYPE pthread_key_t*
#   define LOG4CPLUS_THREAD_LOCAL_INIT ::log4cplus::thread::createPthreadKey()
#   define LOG4CPLUS_GET_THREAD_LOCAL_VALUE( key ) pthread_getspecific(*key)
#   define LOG4CPLUS_SET_THREAD_LOCAL_VALUE( key, value ) pthread_setspecific(*key, value)
#   define LOG4CPLUS_THREAD_LOCAL_CLEANUP( key ) pthread_key_delete(*key)

win32

#   define LOG4CPLUS_THREAD_LOCAL_TYPE DWORD
#   define LOG4CPLUS_THREAD_LOCAL_INIT TlsAlloc()
#   define LOG4CPLUS_GET_THREAD_LOCAL_VALUE( key ) TlsGetValue(key)
#   define LOG4CPLUS_SET_THREAD_LOCAL_VALUE( key, value ) \
       TlsSetValue(key, static_cast(value))
#   define LOG4CPLUS_THREAD_LOCAL_CLEANUP( key ) TlsFree(key)

				
使用起来比较简单，在某个线程中：

    NDC& ndc = log4cplus::getNDC();
    ndc.push("ur ndc string");
    LOG4CPLUS_DEBUG(logger, "this is a NDC test");

    ... ...
    
    ndc.pop();
    
    ... ...
    
    LOG4CPLUS_DEBUG(logger, "There should be no NDC...");
    ndc.remove();
    
当设定输出格式(Layout)为TTCCLayout时，输出如下：

10-21-04 21:32:58, [3392] DEBUG test  - this is a NDC test
10-21-04 21:32:58, [3392] DEBUG test <> - There should be no NDC...

也可以在自定义的输出格式中使用NDC(用%x) ，比如：

    ... ...
    
    std::string pattern = "NDC:[%x]  - %m %n";
    std::auto_ptr _layout(new PatternLayout(pattern));

    ... ...
    
    LOG4CPLUS_DEBUG(_logger, "This is the FIRST log message...")
    NDC& ndc = log4cplus::getNDC();
    ndc.push("ur ndc string");
    LOG4CPLUS_WARN(_logger, "This is the SECOND log message...")
    ndc.pop();
    ndc.remove();
    
    ... ...
    
输出如下：

NDC:[]  - This is the FIRST log message...
NDC:[ur ndc string]  - This is the SECOND log message...

				
另外一种更简单的使用方法是在线程中直接用NDCContextCreator：

    NDCContextCreator _first_ndc("ur ndc string");
    LOG4CPLUS_DEBUG(logger, "this is a NDC test")
    
不必显式地调用push/pop了，而且当出现异常时，能够确保push与pop的调用是匹配的。

    
### 线程 ###

线程是log4cplus中的副产品， 而且仅作了最基本的实现，使用起来也异常简单，只要且必须要
在派生类中重载run函数即可：

class TestThread : public AbstractThread
{
public:

    virtual void run();

};

				
void TestThread::run()
{
    /* do sth. */
    ... ...

}

log4cplus的线程没有考虑同步、死锁，有互斥，实现线程切换的小函数挺别致的：

void log4cplus::thread::yield()
{
#if defined(LOG4CPLUS_USE_PTHREADS)
    ::sched_yield();
#elif defined(LOG4CPLUS_USE_WIN32_THREADS)
    ::Sleep(0);
#endif
}

				
### 套接字 ###

套接字也是log4cplus中的副产品，在namespace log4cplus::helpers中，实现了C/S方式的日志记录。

1. 客户端程序需要做的工作：

/* 定义一个SocketAppender类型的挂接器 */
SharedAppenderPtr _append(new SocketAppender(host, 8888, "ServerName"));

/* 把_append加入到logger中 */
Logger::getRoot().addAppender(_append);

/*  SocketAppender类型不需要Layout, 直接调用宏就可以将信息发往loggerServer了 */
LOG4CPLUS_INFO(Logger::getRoot(), "This is a test: ")

				
【注】 这里对宏的调用其实是调用了SocketAppender::append，里面有一个数据传输约定，即先发送
一个后续数据的总长度，然后再发送实际的数据：

    ... ...

    SocketBuffer buffer = convertToBuffer(event, serverName);
    SocketBuffer msgBuffer(LOG4CPLUS_MAX_MESSAGE_SIZE);

    msgBuffer.appendSize_t(buffer.getSize());
    msgBuffer.appendBuffer(buffer);
   
    ... ...

				
2. 服务器端程序需要做的工作：

/* 定义一个ServerSocket */
ServerSocket serverSocket(port);

/* 调用accept函数创建一个新的socket与客户端连接 */
Socket sock = serverSocket.accept();

				
此后即可用该sock进行数据read/write了,形如：

SocketBuffer msgSizeBuffer(sizeof(unsigned int));

if(!clientsock.read(msgSizeBuffer))
{
    return;
}

unsigned int msgSize = msgSizeBuffer.readInt();

SocketBuffer buffer(msgSize);

if(!clientsock.read(buffer))
{
    return;
}

为了将读到的数据正常显示出来，需要将SocketBuffer存放的内容转换成InternalLoggingEvent格式：

spi::InternalLoggingEvent event = readFromBuffer(buffer);

然后输出：
Logger logger = Logger::getInstance(event.getLoggerName());
logger.callAppenders(event);

				
【注】 read/write是按照阻塞方式实现的，意味着对其调用直到满足了所接收或发送的个数才返回。

				
### 如何将log记录到文件 ###

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

1. FileAppender类

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

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

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

				
2. RollingFileAppender类

构造函数如下：
log4cplus::RollingFileAppender::RollingFileAppender(const log4cplus::tstring& filename,
                                                    long maxFileSize,
                                                    int maxBackupIndex,
                                                    bool immediateFlush)

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

    ... ...
    
    #define LOOP_COUNT 200000
    
    SharedAppenderPtr _append(new RollingFileAppender("Test.log", 5*1024, 5));
    _append->setName("file test");
    _append->setLayout( std::auto_ptr(new TTCCLayout()) );
    Logger::getRoot().addAppender(_append);

    Logger root = Logger::getRoot();
    Logger test = Logger::getInstance("test");
    Logger subTest = Logger::getInstance("test.subtest");

    for(int i=0; i    {
        NDCContextCreator _context("loop");
        LOG4CPLUS_DEBUG(subTest, "Entering loop #" << 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(const log4cplus::tstring& filename,
                                                   DailyRollingFileSchedule schedule,
                                                   bool immediateFlush,
                                                   int maxBackupIndex)
                                                   
filename       : 文件名
schedule       : 存储频度
immediateFlush : 缓冲刷新标志
maxBackupIndex : 最大记录文件数

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

    ... ...
    
    SharedAppenderPtr _append(new DailyRollingFileAppender("Test.log", MINUTELY, true, 5));
    _append->setName("file test");
    _append->setLayout( std::auto_ptr(new TTCCLayout()) );
    Logger::getRoot().addAppender(_append);

    Logger root = Logger::getRoot();
    Logger test = Logger::getInstance("test");
    Logger subTest = Logger::getInstance("test.subtest");

    for(int i=0; i    {
        NDCContextCreator _context("loop");
        LOG4CPLUS_DEBUG(subTest, "Entering loop #" << 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信息的输出。

				
### 优先级控制 ###

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

    Logger root = Logger::getRoot();
    
用户定义的logger都有一个名字与之对应，比如：

    Logger test = Logger::getInstance("test");
    
可以定义该logger的子logger:

    Logger subTest = 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>

using namespace std;
using namespace log4cplus;

int main()
{
    SharedAppenderPtr _append(new ConsoleAppender());
    _append->setName("test");
    Logger::getRoot().addAppender(_append);
    Logger root = Logger::getRoot();

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

    cout << endl << "Before Setting, Default LogLevel" << 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 << "Setting test.subtest to WARN" << 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 << "Setting test.subtest to TRACE" << 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 << "Setting test.subtest to NO_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 << "create a logger test_bak, named \"test_\", too. " << endl;
    Logger test_bak = Logger::getInstance("test");
    cout << "Setting test to INFO, so test_bak also be set to INFO" << endl;
    test.setLogLevel(INFO_LOG_LEVEL);
    LOG4CPLUS_FATAL(root, "test: " << llm.toString(test.getChainedLogLevel()))
    LOG4CPLUS_FATAL(root, "test_bak: " << llm.toString(test_bak.getChainedLogLevel()))

    return 0;
}

输出结果：

Before Setting, Default LogLevel
FATAL - root: DEBUG
FATAL - test: DEBUG
FATAL - test.subtest: DEBUG

Setting test.subtest to WARN
FATAL - root: DEBUG
FATAL - test: DEBUG
FATAL - test.subtest: WARN

Setting test.subtest to TRACE
FATAL - root: DEBUG
FATAL - test: TRACE
FATAL - test.subtest: WARN

Setting test.subtest to NO_LEVEL
FATAL - root: DEBUG
FATAL - test: TRACE
FATAL - test.subtest: TRACE

create a logger test_bak, named "test_", too.
Setting test to INFO, so test_bak also be set to INFO
FATAL - test: INFO
FATAL - test_bak: INFO

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

〖例7〗

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

using namespace std;
using namespace log4cplus;

void ShowMsg(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")
}

int main()
{
    SharedAppenderPtr _append(new ConsoleAppender());
    _append->setName("test");
    _append->setLayout(std::auto_ptr(new TTCCLayout()));
    Logger root = Logger::getRoot();
    root.addAppender(_append);

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

    cout << endl << "trace-log and above allowed" << endl;
    root.setLogLevel(TRACE_LOG_LEVEL);
    ShowMsg();

    cout << endl << "debug-log and above allowed" << endl;
    root.setLogLevel(DEBUG_LOG_LEVEL);
    ShowMsg();

    cout << endl << "info-log and above allowed" << endl;
    root.setLogLevel(INFO_LOG_LEVEL);
    ShowMsg();

    cout << endl << "warn-log and above allowed" << endl;
    root.setLogLevel(WARN_LOG_LEVEL);
    ShowMsg();

    cout << endl << "error-log and above allowed" << endl;
    root.setLogLevel(ERROR_LOG_LEVEL);
    ShowMsg();

    cout << endl << "fatal-log and above allowed" << endl;
    root.setLogLevel(FATAL_LOG_LEVEL);
    ShowMsg();

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

    return 0;
}

输出结果：

all-log allowed
10-17-04 10:11:40,587 [1075298944] TRACE root <> - info
10-17-04 10:11:40,590 [1075298944] DEBUG root <> - info
10-17-04 10:11:40,591 [1075298944] INFO root <> - info
10-17-04 10:11:40,591 [1075298944] WARN root <> - info
10-17-04 10:11:40,592 [1075298944] ERROR root <> - info
10-17-04 10:11:40,592 [1075298944] FATAL root <> - info

trace-log and above allowed
10-17-04 10:11:40,593 [1075298944] TRACE root <> - info
10-17-04 10:11:40,593 [1075298944] DEBUG root <> - info
10-17-04 10:11:40,594 [1075298944] INFO root <> - info
10-17-04 10:11:40,594 [1075298944] WARN root <> - info
10-17-04 10:11:40,594 [1075298944] ERROR root <> - info
10-17-04 10:11:40,594 [1075298944] FATAL root <> - info

debug-log and above allowed
10-17-04 10:11:40,595 [1075298944] DEBUG root <> - info
10-17-04 10:11:40,595 [1075298944] INFO root <> - info
10-17-04 10:11:40,596 [1075298944] WARN root <> - info
10-17-04 10:11:40,596 [1075298944] ERROR root <> - info
10-17-04 10:11:40,596 [1075298944] FATAL root <> - info

info-log and above allowed
10-17-04 10:11:40,597 [1075298944] INFO root <> - info
10-17-04 10:11:40,597 [1075298944] WARN root <> - info
10-17-04 10:11:40,597 [1075298944] ERROR root <> - info
10-17-04 10:11:40,598 [1075298944] FATAL root <> - info

warn-log and above allowed
10-17-04 10:11:40,598 [1075298944] WARN root <> - info
10-17-04 10:11:40,598 [1075298944] ERROR root <> - info
10-17-04 10:11:40,599 [1075298944] FATAL root <> - info

error-log and above allowed
10-17-04 10:11:40,599 [1075298944] ERROR root <> - info
10-17-04 10:11:40,600 [1075298944] FATAL root <> - info

fatal-log and above allowed
10-17-04 10:11:40,600 [1075298944] FATAL root <> - info

log disabled

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

/* DEBUG_LOG_LEVEL  < HELLO_LOG_LEVEL < INFO_LOG_LEVEL */
const LogLevel HELLO_LOG_LEVEL = 15000;

然后定义以下宏即可：

/* define MACRO LOG4CPLUS_HELLO */
#define LOG4CPLUS_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-04 11:17:51,124 [1075298944] UNKNOWN root <> - info

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

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

#define _HELLO_STRING LOG4CPLUS_TEXT("HELLO")

然后修改log4cplus::tstring  defaultLogLevelToStringMethod(LogLevel ll)函数，增加一个判断：

case HELLO_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的Responsibility chain，（即先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-root logger。

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

对于non-root logger来说：
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 <log4cplus/logger.h>
#include <log4cplus/configurator.h>
#include <log4cplus/helpers/stringhelper.h>

using namespace log4cplus;

static Logger logger = Logger::getInstance("log");

void printDebug()
{
    LOG4CPLUS_TRACE_METHOD(logger, "::printDebug()");
    LOG4CPLUS_DEBUG(logger, "This is a DEBUG message");
    LOG4CPLUS_INFO(logger, "This is a INFO message");
    LOG4CPLUS_WARN(logger, "This is a WARN message");
    LOG4CPLUS_ERROR(logger, "This is a ERROR message");
    LOG4CPLUS_FATAL(logger, "This is a FATAL message");
}
int main()
{
    Logger root = Logger::getRoot();
    PropertyConfigurator::doConfigure("urconfig.properties");
    printDebug();

    return 0;
}

运行结果：

1. all_msgs.log
10-17-04 14:55:25,858 [1075298944] TRACE log <> - ENTER: ::printDebug()
10-17-04 14:55:25,871 [1075298944] DEBUG log <> - This is a DEBUG message
10-17-04 14:55:25,873 [1075298944] INFO log <> - This is a INFO message
10-17-04 14:55:25,873 [1075298944] WARN log <> - This is a WARN message
10-17-04 14:55:25,874 [1075298944] ERROR log <> - This is a ERROR message
10-17-04 14:55:25,874 [1075298944] FATAL log <> - This is a FATAL message
10-17-04 14:55:25,875 [1075298944] TRACE log <> - EXIT:  ::printDebug()

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

3. debug_info_msgs.log
10-17-04 14:55:25,871 [1075298944] DEBUG log <> - This is a DEBUG message
10-17-04 14:55:25,873 [1075298944] INFO log <> - This is a INFO message

4. fatal_msgs.log
10-17-04 14:55:25,874 [1075298944] FATAL log <> - This is a FATAL message

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

### 一些可以改进之处 ###

1. 用户自定义LogLevel的实现机制不够开放

在第五篇中曾经介绍过如何实现用户自行定义LogLevel，为了实现比较理想的效果，甚至还需要改log4cplus
的源代码。：（

2. 生成Logger对象的机制可以改进

我在使用时候，经常需要在不同的文件、函数中操作同一个logger，虽然log4cplus实现了树状存储以及根据
名称生成Logger，却没有充分利用这样的特点确保同一个名称对应的logger对象的唯一性，比如以下代码：

    ... ...
    
    Logger logger1 = Logger::getInstance("test");
    Logger logger2 = Logger::getInstance("test");

    Logger * plogger1 = &logger1;
    Logger * plogger2 = &logger2;

    std::cout << "plogger1: " << plogger1 << std::endl << "plogger2: " << plogger2 << std::endl;
    
    ... ...
    
    
运行结果：

plogger1: 0xbfffe5a0
plogger2: 0xbfffe580

				
从结果可以看出，明明是同一个Logger，但每次调用都会产生一个Logger副本，虽然结果是正确的（因为将存
储和操作分开了），但是资源有些浪费，我看了一下log4cplus的代码，其实可以按照如下方式实现（示意性
的）：

#include <iostream>
#include <string>
#include <map>

/* forward declaration */
class Logger;

class LoggerContainer
{
public:

    ~LoggerContainer();

    Logger * getinstance(const std::string & strLogger);

private:

    typedef std::map<:string,> LoggerMap;
    LoggerMap loggerPtrs;
};

class Logger
{
public:
     Logger() {std::cout << "ctor of Logger " << std::endl; }
    ~Logger() {std::cout << "dtor of Logger " << std::endl; }

    static Logger * getInstance( const std::string & strLogger)
    {
        static LoggerContainer defaultLoggerContainer;
        return defaultLoggerContainer.getinstance(strLogger);
    }
};

LoggerContainer::~LoggerContainer()
{
    /* release all ptr in LoggerMap */
    LoggerMap::iterator itr = loggerPtrs.begin();

    for( ; itr != loggerPtrs.end(); ++itr )
 {
     delete (*itr).second;
 }

}

Logger * LoggerContainer::getinstance(const std::string & strLogger)
{
   LoggerMap::iterator itr = loggerPtrs.find(strLogger);

   if(itr != loggerPtrs.end())
   {
       /* logger exist, just return it */
       return (*itr).second;
   }
   else
   {
       /* return a new logger */
       Logger * plogger = new Logger();
       loggerPtrs.insert(std::make_pair(strLogger, plogger));

       return plogger;
   }
}

int main()
{
    Logger * plogger1 = Logger::getInstance("test");
    Logger * plogger2 = Logger::getInstance("test");

    std::cout << "plogger1: " << plogger1 << std::endl << "plogger2: " << plogger2 << std::endl;

    return 0;
}

				
运行结果：

ctor of Logger
plogger1: 0x804fc30
plogger2: 0x804fc30
dtor of Logger

这里的LoggerContainer相当于log4cplus中的Hierarchy类，结果可以看出，通过同一个名称可以获取相同的
Logger实例。

				
还有一些小毛病比如RollingFileAppender和DailyRollingFileAppender的参数输入顺序可以调整成统一方式
等等，就不细说了。

本部分提到了使用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〗
/*
    严格实现步骤1-6，appender输出到屏幕, 其中的布局格式和LogLevel后面会详细解释。
*/
#include <log4cplus/logger.h>
#include <log4cplus/consoleappender.h>
#include <log4cplus/layout.h>

using namespace log4cplus;
using namespace log4cplus::helpers;

int main()
{
    /* step 1: Instantiate an appender object */
    SharedObjectPtr _append (new ConsoleAppender());
    _append->setName("append for test");

    /* step 2: Instantiate a layout object */
    std::string pattern = "%d{%m/%d/%y %H:%M:%S}  - %m [%l]%n";
    std::auto_ptr _layout(new PatternLayout(pattern));

    /* step 3: Attach the layout object to the appender */
    _append->setLayout( _layout );

    /* step 4: Instantiate a logger object */
    Logger _logger = Logger::getInstance("test");

    /* step 5: Attach the appender object to the logger  */
    _logger.addAppender(_append);

    /* step 6: Set a priority for the logger  */
    _logger.setLogLevel(ALL_LOG_LEVEL);

     /* log activity */
    LOG4CPLUS_DEBUG(_logger, "This is the FIRST log message...")
    sleep(1);
    LOG4CPLUS_WARN(_logger, "This is the SECOND log message...")

    return 0;
}

输出结果：
10/14/04 09:06:24  - This is the FIRST log message... [main.cpp:31]
10/14/04 09:06:25  - This is the SECOND log message... [main.cpp:33]

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

using namespace log4cplus;
using namespace log4cplus::helpers;

int main()
{
    /* step 1: Instantiate an appender object */
    SharedAppenderPtr _append(new ConsoleAppender());
    _append->setName("append test");

    /* step 4: Instantiate a logger object */
    Logger _logger = Logger::getInstance("test");

    /* step 5: Attach the appender object to the logger  */
    _logger.addAppender(_append);

    /* log activity */
    LOG4CPLUS_DEBUG(_logger, "This is the FIRST log message...")
    sleep(1);
    LOG4CPLUS_WARN(_logger, "This is the SECOND log message...")

    return 0;
}

输出结果：
DEBUG - This is the FIRST log message...
WARN - This is the SECOND log message...

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

int main()
{
    /* step 1: Instantiate an appender object */
    SharedAppenderPtr _append(new ConsoleAppender());
    _append->setName("append test");

    /* step 4: Instantiate a logger object */
    Logger _logger = Logger::getInstance("test");

    /* step 5: Attach the appender object to the logger  */
    _logger.addAppender(_append);

    /* log activity */
    LOG4CPLUS_TRACE(_logger, "This is"  << " just a t" << "est." << std::endl)
    LOG4CPLUS_DEBUG(_logger, "This is a bool: " << true)
    LOG4CPLUS_INFO(_logger, "This is a char: " << 'x')
    LOG4CPLUS_WARN(_logger, "This is a int: " << 1000)
    LOG4CPLUS_ERROR(_logger, "This is a long(hex): " << std::hex << 100000000)
    LOG4CPLUS_FATAL(_logger, "This is a double: "  << std::setprecision(15)  << 1.2345234234)

    return 0;
}

输出结果：
DEBUG - This is a bool: 1
INFO - This is a char: x
WARN - This is a int: 1000
ERROR - This is a long(hex): 5f5e100
FATAL - This is a double: 1.2345234234

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

using namespace log4cplus::helpers;

void printMsgs(void)
{
    std::cout << "Entering printMsgs()..." << std::endl;
    LogLog::getLogLog()->debug("This is a Debug statement...");
    LogLog::getLogLog()->warn("This is a Warning...");
    LogLog::getLogLog()->error("This is a Error...");
    std::cout << "Exiting printMsgs()..." << std::endl << std::endl;
}

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

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

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

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

    printMsgs();

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

    std::cout << "Turning on quiet mode..." << std::endl;
    LogLog::getLogLog()->setQuietMode(true);
    printMsgs();

    return 0;
}

输出结果：
Entering printMsgs()...
log4cplus:WARN This is a Warning...
log4cplus:ERROR This is a Error...
Exiting printMsgs()...

Turning on debug...
Entering printMsgs()...
log4cplus: This is a Debug statement...
log4cplus:WARN This is a Warning...
log4cplus:ERROR This is a Error...
Exiting printMsgs()...

Turning on quiet mode...
Entering printMsgs()...
Exiting printMsgs()...

需要指出的是，输出信息中总是包含"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>
using namespace log4cplus;
int main()
{    
/* step 1: Instantiate an appender object */
    SharedAppenderPtr _append(new FileAppender("Test.log"));
    _append->setName("file log test");
    /* step 4: Instantiate a logger object */
    Logger _logger = Logger::getInstance("test.subtestof_filelog");
    /* step 5: Attach the appender object to the logger  */
    _logger.addAppender(_append);
    /* log activity */
    int i;
    for( i = 0; i < 5; ++i )
    {
        LOG4CPLUS_DEBUG(_logger, "Entering loop #" << i << "End line #")
    }
    return 0;
}

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

DEBUG - Entering loop #0End line #
DEBUG - Entering loop #1End line #
DEBUG - Entering loop #2End line #
DEBUG - Entering loop #3End line #
DEBUG - Entering loop #4End line #

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

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

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

比如以下代码片段：

    ... ...

    /* step 1: Instantiate an appender object */
    SharedObjectPtr _append (new ConsoleAppender());
    _append->setName("append for test");

    /* step 2: Instantiate a layout object */
    std::auto_ptr  _layout(new log4cplus::SimpleLayout());

    /* step 3: Attach the layout object to the appender */
    _append->setLayout( _layout );

    /* step 4: Instantiate a logger object */
    Logger _logger = Logger::getInstance("test");

    /* step 5: Attach the appender object to the logger  */
    _logger.addAppender(_append);

     /* log activity */
    LOG4CPLUS_DEBUG(_logger, "This is the simple formatted log message...")
    
    ... ...
    
    
将打印结果：
DEBUG - This is the simple formatted log message...

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

    ... ...

    /* step 1: Instantiate an appender object */
    SharedObjectPtr _append (new ConsoleAppender());
    _append->setName("append for test");
   
    /* step 2: Instantiate a layout object */
    std::string pattern = "%d{%m/%d/%y %H:%M:%S}  - %m [%l]%n";
    std::auto_ptr _layout(new PatternLayout(pattern));
    
    /* step 3: Attach the layout object to the appender */
    _append->setLayout( _layout );

    /* step 4: Instantiate a logger object */
    Logger _logger = Logger::getInstance("test_logger.subtest");

    /* step 5: Attach the appender object to the logger  */
    _logger.addAppender(_append);

     /* log activity */
    LOG4CPLUS_DEBUG(_logger, "teststr")
    
    ... ...
    
输出结果：
10/16/04 18:51:25  - teststr [main.cpp:51]

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

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

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

（1）"%%"，转义为%, 即，std::string pattern = "%%" 时输出: "%"
（2）"%c"，输出logger名称，比如std::string pattern ="%c" 时输出: "test_logger.subtest"，
     也可以控制logger名称的显示层次，比如"%c{1}"时输出"test_logger"，其中数字表示层次。
（3）"%D"，显示本地时间，当std::string pattern ="%D" 时输出:"2004-10-16 18:55:45"，%d显示标准时间，
     所以当std::string pattern ="%d" 时输出 "2004-10-16 10:55:45" （因为我们是东8区，差8个小时啊）。
     可以通过%d{...}定义更详细的显示格式，比如%d{%H:%M:%s}表示要显示小时:分钟：秒。大括号中可显示的
     预定义标识符如下：
     
%a -- 表示礼拜几，英文缩写形式，比如"Fri"
%A -- 表示礼拜几，比如"Friday"
%b -- 表示几月份，英文缩写形式，比如"Oct"
%B -- 表示几月份，"October"
%c -- 标准的日期＋时间格式，如 "Sat Oct 16 18:56:19 2004"
%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 -- 表示现在是上午还是下午， AM or PM
%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::string pattern ="%F" 时输出: "main.cpp"
（5）"%L"，输出当前记录器所在的文件行号，比如std::string pattern ="%L" 时输出: "51"
（6）"%l"，输出当前记录器所在的文件名称和行号，比如std::string pattern ="%L" 时输出:
     "main.cpp:51"
（7）"%m"，输出原始信息，比如std::string pattern ="%m" 时输出: "teststr"，即上述代码中
     LOG4CPLUS_DEBUG的第二个参数，这种实现机制可以确保原始信息被嵌入到带格式的信息中。
（8）"%n"，换行符，没什么好解释的
（9）"%p"，输出LogLevel，比如std::string pattern ="%p" 时输出: "DEBUG"
（10）"%t"，输出记录器所在的线程ID，比如std::string pattern ="%t" 时输出: "1075298944"
（11）"%x"，嵌套诊断上下文NDC (nested diagnostic context) 输出，从堆栈中弹出上下文信息，NDC可以用对
      不同源的log信息（同时地）交叉输出进行区分，关于NDC方面的详细介绍会在下文中提到。
（12）格式对齐，比如std::string pattern ="%-10m"时表示左对齐，宽度是10，此时会输出"teststr   "，当
      然其它的控制字符也可以相同的方式来使用，比如"%-12d"，"%-5p"等等（刚接触log4cplus文档时还以为
      "%-5p"整个字符串代表LogLevel呢，呵呵）。

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

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

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

    ... ...

    /* step 1: Instantiate an appender object */
    SharedObjectPtr _append (new ConsoleAppender());
    _append->setName("append for test");

    /* step 2: Instantiate a layout object */
    std::auto_ptr _layout(new TTCCLayout());

    /* step 3: Attach the layout object to the appender */
    _append->setLayout( _layout );

    /* step 4: Instantiate a logger object */
    Logger _logger = Logger::getInstance("test_logger");

    /* step 5: Attach the appender object to the logger  */
    _logger.addAppender(_append);

     /* log activity */
    LOG4CPLUS_DEBUG(_logger, "teststr")
    
    ... ...
    
输出结果：
10-16-04 19:08:27,501 [1075298944] DEBUG test_logger <> - teststr

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

    ... ...
    
    /* step 2: Instantiate a layout object */
    std::auto_ptr _layout(new TTCCLayout(true));
    
    ... ...
    
输出结果：
10-16-04 11:12:47,678 [1075298944] DEBUG test_logger <> - teststr

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

				
### 简介 ###

log4cplus是C++编写的开源的日志系统，前身是java编写的log4j系统.受Apache Software License
保护。作者是Tad E. Smith。log4cplus具有线程安全、灵活、以及多粒度控制的特点，通过将信息划分
优先级使其可以面向程序调试、运行、测试、和维护等全生命周期； 你可以选择将信息输出到屏幕、文件、
NT event log、甚至是远程服务器；通过指定策略对日志进行定期备份等等。

### 下载 ###

最新的log4cplus可以从以下网址下载 http://log4cplus.sourceforge.net
本文使用的版本为：1.0.2

### 安装 ###

1. linux下安装

tar xvzf log4cplus-x.x.x.tar.gz
cd log4cplus-x.x.x
./configure --prefix=/where/to/install
make
make install

这里我采用缺省安装路径：/usr/local，下文如无特别说明，均以此路径为准。

2. windows下安装

不需要安装，有一个msvc6存放包括源代码和用例在内的开发工程（for VC6 only），使用之前请先编译
"log4cplus_dll class"工程生成dll，或者编译"log4cplus_static class"工程生成lib.

### 使用前的配置 ###

1. linux下的配置

确保你的Makefile中包含 /usr/local/lib/liblog4cplus.a（静态库）或  -llog4cplus（动态库）即可，
头文件在/usr/local/include/log4cplus目录下。对于动态库，要想正常使用，还得将库安装路径加入到
LD_LIBRARY_PATH 中，我一般是这样做的：以管理员身份登录，在/etc/ld.so.conf中加入安装路径，这里
是/usr/local/lib，然后执行ldconfig使设置生效即可。

2. windows下的配置

将"log4cplus_dll class"工程或"log4cplus_static class"工程的dsp 文件插入到你的工程中，或者直接
把两个工程编译生成的库以及头文件所在目录放到你的工程的搜索路径中，如果你使用静态库，请在你的工程中
"project/setting/C++"的preprocessor definitions中加入LOG4CPLUS_STATIC。

### 构成要素介绍 ###

虽然功能强大，应该说log4cplus用起来还是比较复杂的，为了更好地使用它，先介绍一下它的基本要素。

Layouts      ：布局器，控制输出消息的格式.
Appenders    ：挂接器，与布局器紧密配合，将特定格式的消息输出到所挂接的设备终端
               （如屏幕，文件等等)。
Logger       ：记录器，保存并跟踪对象日志信息变更的实体，当你需要对一个对象进行
               记录时，就需要生成一个logger。
Categories   ：分类器，层次化（hierarchy）的结构，用于对被记录信息的分类，层次中
               每一个节点维护一个logger的所有信息。
Priorities   ：优先权，包括TRACE, DEBUG, INFO, WARNING, ERROR, FATAL。

				
本文介绍了log4cplus基本概念，以及如何安装，配置，下一篇将通过例子介绍如何使用log4cplus。

第一种方案是大家熟悉的截获定时消息的途径。在Windows提供给我们使用的系统资源当中，有一种称为“定时器（Timer）”的特殊资源，在申请了这类资源的程序当中每间隔一段时间会接收到值为WM_TIMER的消息。需要定时执行的代码可以放在该消息的处理部分。如果在VC中，我们可以具体按照以下步骤实现这一目的：

1. 利用MFC AppWizard创建一个标准的工程，接受所有缺省选项。名为s1

2. 在Classview中选中“CMainFrame”类，然后按Ctrl+W激活ClassWizard，在“Message Map”选项卡中Class Name选“CMainFrame”，接着在“Message”中选“WM_TIMER”，最后按下“Add Funcation”。以上步骤加入了对WM_TIMER消息的映射处理。

3. 回到Classview中，双击“OnCreate”成员函数，在函数的末尾添加申请Timer的语句：
   SetTimer(100,1000,NULL);//申请一个标识值为100的Timer，定时间隔为1000毫秒（1秒）。

4. 在“Classview”中双击OnTimer函数，输入要定时实现的代码。本例子中为：
   MessageBeep(1000);;//每隔一秒发出通告声

5. 编译并执行之，我们可以每隔一秒就听到声音。这正是我们在OnTimer函数内要求执行的。

实际当中，我们可以将“MessageBeep(1000);”换成任何我们想完成的任务，譬如定时存盘等。

第二种方案也利用Timer资源，但却是采用已经编写好的代码��我们可以加入一个具有定时功能的组件至当前工程当中。这种方法特别适用于基于对话框的工程。具体步骤如下：

1. 利用MFC AppWizard创建一个基于对话框的工程，其余接受所有缺省选项。名为s2。

2. 在ResourceView中，双击IDD_S2_DIALOG，显示对话框，将其中的“To do:”改为“定时触发演示的例子”，表明工程的作用。

3. 右击对话框编辑区，在弹出的右键菜单中选择“Insert ActiveX Control”，从弹出的列表框中选择“Timer Object”，确定后会在对话框内出现一个Timer对象。

4. 我们右击Timer对象，从弹出的菜单中选择“Properties”，接着选“All”选项卡，将其中的Interval值设为5000，即每隔5秒发生一次Timer事件。

5. 回到对话框编辑界面，双击Timer，产生一个CS2Dlg::OnTimerTimer1成员函数，接受缺省值，并在函数实现部分输入：
   MessageBox("定时触发消息框","定时演示" ,MB_OK);

6. 编译并运行此工程，将会在产生的对话框运行期间，每隔5秒弹出一个消息框。

同样，我们可以以任何自己的代码来替换5中的消息框语句。详细见附例s2。

第三种方法是采用线程技术。众所周知，Windows 9X是一个基于多线程的多任务操作系统，在内核中以线程作为调度的基本单位，由系统分时间片进行调度。利用这一点，我们可以在程序当中创建一个“司职”计时的线程，通过线程间的同步来定时触发我们要完成的任务的代码。不象前两种方法需要至少有一个窗口作为接受消息的主窗口，采用线程技术实现定时触发将免去创建窗口的麻烦以及带来的系统各种资源的消耗。下面我们来举一个例子来说明这个问题：我们在CmyApp类的Initstance成员中不建立主窗口而是创建一个工作线程，该线程休眠一定的时间后，自动调用主线程的SomeThing函数。为了支持线程的运行，我们需要给CmyApp类增加相应的线程函数。下面，我们还是一步一步的实现：

1. 利用MFC AppWizard创建一个标准工程，其中为不产生多余的代码，不选文档/视图支持，并选择单文档。工程名为S3。

2. 在CS3App:: InitInstance()中用“/* … */”注释掉“return TRUE;”之前的所有代码。这是为了不建立窗口。并添加以下代码：
   ExitFlag=TRUE;//是否结束主线程的循环的标志变量。因为子线程严重依赖主线程，所以在本例子中为了避免没有主窗口而提前结束应用程序，从而使子线程无法存在，所以给主线程一个循环，知道全局变量ExitFlag在子线程退出前被设置成FALSE为止.
   StartThread();//启动线程
   do{}while(ExitFlag);//直到结束子线程
   ::MessageBox(NULL,"主线程结束！","定时触发演示",MB_OK);
   return TRUE;

3. 在Globals中增加一标志变量“ExitFlag”，类型为BOOL。它被主线程用来判断是否结束自身运行。

4. 通过ClassView在CS3App的Public部分声明以下函数:
   void StartThread(void); //启动线程
   static UINT ThreadFunction(void); //主要执行代码的函数
   static UINT StaticThreadFunc(LPVOID lpparam);//设置线程时用到的函数
   需要特别指出的是，用AfxBeginThread进行线程设置时，第一参数必须象本例所指出的那样声明为Static ，不然参数转换的错误会扰得你不得安宁。

5. 在StartThread中输入如下代码：
   AfxBeginThread(StaticThreadFunc,this);//建立并启动线程

6. 在StaticThreadFunc中输入如下代码：
   return ThreadFunc();//调用完成主要线程代码的函数，注意一定要是Static.

7. 实现ThreadFunction：
   int i;
   i=5;//触发5次
   while(i--)
   {
   Sleep(5000);//间隔5秒
   ::MessageBox (NULL,"我被定时触发了！","定时触发演示",MB_OK);
   }
   ExitFlag=FALSE;//ExitFlag是一全局变量，通知主线程结束运行。
   return 0;
   }

8. 编译并运行工程，将看不到应用程序窗口，但可以看到每隔5秒，桌面上出现一个消息框，5次后弹出主线程结束的消息框。

以上即本人在学习当中解决 Windows下实现定时触发而采取的一些办法，各自方法的特点也在介绍当中指出。希望所述能给大家一点帮助，更希望能得到大家的指正。如果您有什么意见和设想，欢迎发E-Mail给我（yangshanhe@21cn.com）。

==

很早之前2000年的拙作，集在一起，免得自己都不清楚干过什么。

IWebBrowser2 的属性和方法给了你确切的控制导航和用户接口的途径，但是如果你不能够检测到浏览器正在处理什么以及何时处理什么，你还是没有全面的控制它.因此，WebBrowser控件和Internet Explorer暴露出事件，通过此你可以必要时监视活动以及处理某些活动. 举例来说，假设你建立一个intranet应用程序, 你想限制用户用户访问某些web页.利用Internet Explorer的时间处理句柄,你可以指令应用程序在用户试图访问受限的URL时候取消导航完成。

事件 和 引出的接口

无论何时一个COM 对象需要客户应用程序一个事件发生了, COM 对象发送一个叫做事件的消息. 发送消息的处理过程会激发一个事件. 但如果事件没有任何监听者会如何？ 事件每次都发生吗? 显然, 客户应用程序监听这些事件并控制COM对象.如果一个客户应用想接收来自COM 对象的事件,它"advises" 实际的COM 对象的.

一个COM 对象为了通客户通信, 对象自身必须支持一个或者多个外引接口.一个 COM 对象支持的外引接口是作为可连接对象引用. 要成为一个可连接对象，COM对象必须实现IConnectionPointContainer 接口。通过此接口，客户可认识到那些外引接口被服务器支持. 外引接口实际通过连接点由客户挂接入COM实现。实现外引接口的客户部分众所周知是通过事件接收槽（event sink）实现的.

单一的连接点由服务器支持每一个外引接口.每一个连接点能够操纵一种类型的外引接口且至少支持IConnectionPoint 接口. 图7-1 描述了可连接的对象和它的客户之间的关系.

Figure 7-1. Connectable object and its client.

每一个服务器必须实现2个接口以便实现客户可以接收事件—IConnectionPointContainer 和 IConnectionPoint. 我们将先看看这些接口之后将检视实现事件的不同途径.

IConnectionPointContainer

每一个可连接对象实现了IConnectionPointContainer. 通过此接口, 试图接收事件的客户可找出关于可连接对象支持的不同的连接点. 通过调用QueryInterface using 客户可以获得服务器支持的任何接口的指针. (你可以使用任何接口指针调用QueryInterface, 因为全部 COM 接口继承自IUnknown.) 之后客户可以使用IConnectionPointContainer 接口的2个方法中的之一获取可连接点。 如表7-1, 获得可连接点

Table 7-1 Methods of the IConnectionPointContainer Interface

IConnectionPoint

一旦客户知道哪个连接点可被连接对象服务器支持, 客户就可建立同可连接对象的连接。客户通知可连接对象将要在全部事件中接收那些事件.当客户不再需要接收来自可连接对象的事件,客户解除对对象的通知. 表7-2 展示了 IConnectionPoint 接口可被客户连接的. (大多数时候,你将连接到仅仅表中头两个)

Table 7-2 Methods of the IConnectionPoint Interface

接收事件的途径

依靠开发工具你创建客户应用程序,你可以接收事件通过不同的途径. 显然, 在Vb中接收事件同在VC中接收事件相比是如此不同和容易.在 C++ 应用中,你可以用不同的技术，通过使用 ATL, MFC, 或者标准C++.

Visual Basic 中接收事件

Visual Basic是创建大多数类型应用的最轻松的工具, 所以我告诉你VB是处理事件最溶的工具时也不要惊奇. ATL 和 Visual Basic 示例我们同样的工作,但是ATL花费了我4个小时, 而 Visual Basic 例子仅仅只花20 分钟.别说我错了—我是ATL, 和 MFC， C++的忠实信徒,  尤其是你建立一个接口的时候.但是 Visual Basic当建立客户应用程序从类似IE这样的服务器接收事件时是伟大的工具.

OK,如何从Visual Basic 应用程序中接收事件？当宿主WebBrowser 控件,你不必做任何特别的事. Visual Basic 在form上为WebBrowser 控件接收事件.你所需要做的全部事情就是未你要接收的任何事件创建一个事件处理句柄.

你象创建其他事件句柄一样创建句柄 (例如Form_Load event). 从Procedure下拉列表框中选择你象控制的句柄, 在事件句柄中,加入任何你型在事件激发时执行的任何代码.

当自动化服务器时候接收事件, 例如在VB应用中的Internet Explorer,过程直截了当.首先设置对服务器的类型库的引用, 你可以访问Project/References 菜单.之后，采用WithEvents 关键字声明服务器对象的变量.举例, 如果你自动化Internet Explorer, 你将声明变量如下:

												
														Dim WithEvents InternetExplorer1 As InternetExplorer
												
										

下一步，采用new或者其他 关键字创建实例变量 ，如下：:

												
														Set InternetExplorer1 = CreateObject("InternetExplorer.Application.1")
												
										

或者:

												
														Set InternetExplorer1 = New InternetExplorer
												
										

当你采用以上途径生成实例接收事件, Visual Basic 自动为你初