step by step 之餐饮管理系统四(日志模块实现)

　　三天前基本上把数据库表设计的文档写好，今天想到了一个问题，还要再加几个表，一个是log表，用来记录系统日志，另外再加几个字典表，一些需要配置的数据但又不好放在像xml文件里面的数据可以放在这些字典表里面。

　　从今天开始就正式进入系统设计与编码了，详细设计文档等系统做好后再补充了，因为一开始全部写好不大现实，中间过程中会不断地去迭代。现在的想法是每个模块分别去实现，然后再分别记录下来。

　　今天要写的是日志模块，因为在生产环境中，好的日志至于重要，系统运行时出现的任何问题可以通过日志记录下来，对于发现与解决问题非常有帮助。因为日志是一个相对比较通用的模块，所以先设计好如果写日志模块，之后再写通用类模块，再数据库访问层与用户自定义控件，然后再数据实体与业务处理层，最后再写用户表现层。

　　因为此次不使用第二方控件，所以不考虑像log4net，微软enterprise中好的日志控件，但是看了它们的代码，总体思想都差不多，就是各种级别的日志信息应该以什么样的格式输出到哪种介质中，也就是输出源，像文本文件还是数据库，还是控制台，还是系统日志邮件等等。基于它们的思想，把构思记录下来：

日志最主要的就是一个日志器与附加器，像log4net中可以定义多个日志器，一个日志器可以附加多个输出源，而日志仓库就是如何存储和管理日志器，过虑器如果过虑各种级别的日志，而layout就是如何显示输出的消息。

1、输出源只包含文本文件，数据库，系统日志和邮件。

2、日志级别分别为Fatal, Error, Warn, Info, Debug。

还是拿代码为例子来讲吧,首先定义一个日志器接口与日志操作接口ILog,日志器得先有一个名字，它的方法就是一个Log和IsEnabledFor,ILog包含的方法如下，用过log4net等日志控件的应该很熟悉。

日志器接口详细代码如下：

 public interface ILogger
    {
        /// <summary>
        /// Gets the name of the logger.
        /// </summary>
        string Name { get; }

        /// <summary>
        /// This generic form is intended to be used by wrappers.
        /// </summary>
        void Log(LogCategory level, object message, Exception exception);

        bool IsEnabledFor(LogCategory level);
    }

然后再定义一个包装接口

   public interface ILoggerWrapper
    {
        ILogger Logger
        {
            get;
        }
    }

定义ILog接口，最后调用的都是在这里定义的接口

 public interface ILog : ILoggerWrapper
    {
        void Debug(object message);

        void Debug(object message, Exception exception);

        void DebugFormat(string format, params object[] args);

        void Info(object message);

        void Info(object message, Exception exception);

        void InfoFormat(string format, params object[] args);

        void Warn(object message);

        void Warn(object message, Exception exception);

        void WarnFormat(string format, params object[] args);

        void Error(object message);

        void Error(object message, Exception exception);

        void ErrorFormat(string format, params object[] args);

        void Fatal(object message);

        void Fatal(object message, Exception exception);

        void FatalFormat(string format, params object[] args);


        bool IsDebugEnabled
        {
            get;
        }

        bool IsInfoEnabled
        {
            get;
        }

        bool IsErrorEnabled
        {
            get;
        }

        bool IsWarnEnabled
        {
            get;
        }

        bool IsFatalEnabled
        {
            get;
        }
    }

日志器有了，可以附加器呢，也就是源出源，其实真正的任务都是委托这些具体的附加器去做的呢，为什么log4net那么强大，我想它的附加器如此之多也是一大原因吧，基本上我们能想到的它都想到了，我们没有想到的它也想到了，下面就定义的几个具体的附加器。

附加器如何跟前面的说的日志器关联呢，20个附加器不可能都直接与日志器去关联吧，所以定义一个所有附加器要实现的接口IAppender.

 public  interface IAppender
    {
       string Name
       {
           get;
           set;
       }

       void Close();

       void DoAppender(LogCategory level, object message, Exception exception);
    }

拿文本文件为例，日志的输出源就是文本文件，消息写到这个介质上，下面是一个基类，然后子类就是继承这个类实现Write方法去写日志信息：

  public class TextWriterAppender : TextWriter
    {
        private TextWriter m_writer;

        public TextWriter Writer
        {
            get { return m_writer; }
            set { m_writer = value; }
        }

        virtual public string Name
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }

        #region Public Methods

        /// <summary>
        /// Closes the writer and releases any system resources associated with the writer
        /// </summary>
        /// <remarks>
        /// <para>
        /// </para>
        /// </remarks>
        override public void Close()
        {
            m_writer.Close();
        }

        /// <summary>
        /// Dispose this writer
        /// </summary>
        /// <param name="disposing">flag indicating if we are being disposed</param>
        /// <remarks>
        /// <para>
        /// Dispose this writer
        /// </para>
        /// </remarks>
        override protected void Dispose(bool disposing)
        {
            if (disposing)
            {
                ((IDisposable)m_writer).Dispose();
            }
        }

        /// <summary>
        /// Flushes any buffered output
        /// </summary>
        /// <remarks>
        /// <para>
        /// Clears all buffers for the writer and causes any buffered data to be written 
        /// to the underlying device
        /// </para>
        /// </remarks>
        override public void Flush()
        {
            m_writer.Flush();
        }

        /// <summary>
        /// Writes a character to the wrapped TextWriter
        /// </summary>
        /// <param name="value">the value to write to the TextWriter</param>
        /// <remarks>
        /// <para>
        /// Writes a character to the wrapped TextWriter
        /// </para>
        /// </remarks>
        override public void Write(char value)
        {
            m_writer.Write(value);
        }

        /// <summary>
        /// Writes a character buffer to the wrapped TextWriter
        /// </summary>
        /// <param name="buffer">the data buffer</param>
        /// <param name="index">the start index</param>
        /// <param name="count">the number of characters to write</param>
        /// <remarks>
        /// <para>
        /// Writes a character buffer to the wrapped TextWriter
        /// </para>
        /// </remarks>
        override public void Write(char[] buffer, int index, int count)
        {
            m_writer.Write(buffer, index, count);
        }

        /// <summary>
        /// Writes a string to the wrapped TextWriter
        /// </summary>
        /// <param name="value">the value to write to the TextWriter</param>
        /// <remarks>
        /// <para>
        /// Writes a string to the wrapped TextWriter
        /// </para>
        /// </remarks>
        override public void Write(String value)
        {
            m_writer.Write(value);
        }

        public override Encoding Encoding
        {
            get { return m_writer.Encoding; }
        }

        #endregion
    }

日志器与附加器都有了，怎么去连接它们了，最后我想还是用泛型比较灵活，定义如下：

  public class LogFactory<L, A> : ILog
        where L : ILogger, new()
        where A : IAppender, new()
    {

        virtual public void Debug(object message)
        {
#if DEBUG
            Logger.Log(m_levelDebug, message, null);
#endif
        }

        virtual public void Debug(object message, Exception exception)
        {
#if DEBUG
            Logger.Log(m_levelDebug, message, exception);
#endif
        }

        virtual public void DebugFormat(string format, params object[] args)
        {
#if DEBUG
            if (IsDebugEnabled)
            {
                Logger.Log(m_levelDebug, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), null);
            }
#endif
        }

        virtual public void Info(object message)
        {
            Logger.Log(LevelInfo, message, null);
        }

        virtual public void Info(object message, Exception exception)
        {
            Logger.Log(LevelInfo, message, exception);
        }

        virtual public void InfoFormat(string format, params object[] args)
        {
            if (IsInfoEnabled)
            {
                Logger.Log(LevelInfo, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), null);
            }
        }

        virtual public void Warn(object message)
        {
            Logger.Log(LevelWarn, message, null);
        }

        virtual public void Warn(object message, Exception exception)
        {
            Logger.Log(LevelWarn, message, exception);
        }

        virtual public void WarnFormat(string format, params object[] args)
        {
            if (IsWarnEnabled)
            {
                Logger.Log(LevelWarn, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), null);
            }
        }

        virtual public void Error(object message)
        {
            Logger.Log(LevelError, message, null);
        }

        virtual public void Error(object message, Exception exception)
        {
            Logger.Log(LevelError, message, exception);
        }

        virtual public void ErrorFormat(string format, params object[] args)
        {
            if (IsErrorEnabled)
            {
                Logger.Log(LevelError, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), null);
            }
        }

        virtual public void Fatal(object message)
        {
            Logger.Log(LevelFatal, message, null);
        }

        virtual public void Fatal(object message, Exception exception)
        {
            Logger.Log(LevelFatal, message, exception);
        }

        virtual public void FatalFormat(string format, params object[] args)
        {
            if (IsFatalEnabled)
            {
                Logger.Log(LevelFatal, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), null);
            }
        }

        virtual public bool IsDebugEnabled
        {
            get
            {
                return Logger.IsEnabledFor(m_levelDebug);
            }
        }

        virtual public bool IsInfoEnabled
        {
            get
            {
                return Logger.IsEnabledFor(m_levelInfo);
            }
        }

        virtual public bool IsErrorEnabled
        {
            get
            {
                return Logger.IsEnabledFor(m_levelError);
            }
        }

        virtual public bool IsWarnEnabled
        {
            get
            {
                return Logger.IsEnabledFor(m_levelWarn);
            }
        }

        virtual public bool IsFatalEnabled
        {
            get
            {
                return Logger.IsEnabledFor(m_levelFatal);
            }
        }

        private LogCategory m_levelDebug;

        public LogCategory LevelDebug
        {
            get { return LogCategory.Debug; }
            set { m_levelDebug = LogCategory.Debug; }
        }
        private LogCategory m_levelInfo;

        public LogCategory LevelInfo
        {
            get { return LogCategory.Info; }
            set { m_levelInfo = LogCategory.Info; }
        }
        private LogCategory m_levelWarn;

        public LogCategory LevelWarn
        {
            get { return LogCategory.Warn; }
            set { m_levelWarn = LogCategory.Warn; }
        }
        private LogCategory m_levelError;

        public LogCategory LevelError
        {
            get { return LogCategory.Error; }
            set { m_levelError = LogCategory.Error; }
        }
        private LogCategory m_levelFatal;

        public LogCategory LevelFatal
        {
            get { return LogCategory.Fatal; }
            set { m_levelFatal = LogCategory.Fatal; }
        }

        public ILogger Logger
        {
            get { return new L(); }
        }
    }

把上面的泛型类闭合一个日志类：

 public class LogBase<A> : LogFactory<LogBase<A>, A>, ILogger
        where A : IAppender, new()
    {
        private LogCategory m_logLevel;
        public string Name
        {
            get
            {
                return "LogBase";
            }
        }

        private A m_instance;

        public A Instance
        {
            get
            {
                if (m_instance == null)
                {
                    m_instance = new A();
                }
                return m_instance;
            }
            set { m_instance = value; }
        }

        public void Log(LogCategory level, object message, Exception exception)
        {
            Instance.DoAppender(level, message, exception);
        }

        public bool IsEnabledFor(LogCategory level)
        {
            switch (level)
            {
                case LogCategory.Fatal:
                    LevelFatal = LogCategory.Fatal;
                    break;
                case LogCategory.Error:
                    LevelError = LogCategory.Error;
                    break;
                case LogCategory.Warn:
                    LevelWarn = LogCategory.Warn;
                    break;
                case LogCategory.Debug:
                    LevelDebug = LogCategory.Debug;
                    break;
                case LogCategory.Info:
                    LevelInfo = LogCategory.Info;
                    break;
                default:
                    m_logLevel = LogCategory.Info;
                    break;
            }

            return true;
        }
    }

再关闭一个泛型参数：

  public class TxtFileLog :  LogBase<TxtFileLog>, IAppender
    {
        private string m_name;
        private FileLogWriter m_writer;

        public TxtFileLog()
        {
            if (m_writer == null)
            {
                m_writer = new FileLogWriter();
            }
        }

        public FileLogWriter Writer
        {
            get { return m_writer; }
            set { m_writer = value; }
        }

        public new string Name
        {
            get
            {
                return m_name;
            }
            set
            {
                m_name = value;
            }
        }

        public void Close()
        {
            m_writer.Close();
        }

        public void DoAppender(LogCategory level, object message, Exception exception)
        {
            m_writer.Write(Convert.ToString(message), level, (LogMessage)exception);
        }

上面的类实现了日志器与附加器的连接，然后就可以去客户端验证好不好用了：

            ILog log = new TxtFileLog();
            log.Debug("Are you OK??");

打印如下信息：

这只是第一步，后面还得写数据库与邮件附加器的输出方法。写一个好的日志器还真不容易。之后会把一些可以配置的东西放到配置文件里面，

接下来就写通用类与数据库访问层。

注：需要完整源码的可以mark下，无偿发到你邮箱