• log4net简单用法


    一、NuGet在Server,mvc中添加Common.Logging和common.Logging.Log4Net如下图

    二、在Server层创建logger类

    <?xml version="1.0" encoding="utf-8" ?>
    <log4net>
      <!--级别层级ALL<DEBUG<INFO<WARN<ERROR<FATAL<OFF -->
      <!--调试日志-->
      <appender name="debugLog" type="log4net.Appender.RollingFileAppender,log4net" >
        <param name="File" value="logsdebugdebug.log" />
        <param name="AppendToFile" value="true" />
        <param name="RollingStyle" value="Date" />
        <param name="DatePattern" value="yyyyMMdd" />
        <param name="StaticLogFileName" value="true" />
        <layout type="log4net.Layout.PatternLayout,log4net">
          <param name="ConversionPattern" value="%d{yyyy-MM-dd HH:mm:ss}%newline%message%n" />
        </layout>
        <filter type="log4net.Filter.LevelRangeFilter">
          <param name="LevelMin" value="DEBUG" />
          <param name="LevelMax" value="DEBUG" />
        </filter>
      </appender>
    
      <!--信息日志-->
      <appender name="infoLog" type="log4net.Appender.RollingFileAppender,log4net" >
        <param name="File" value="logsinfoinfo.log" />
        <param name="AppendToFile" value="true" />
        <param name="RollingStyle" value="Date" />
        <param name="DatePattern" value="yyyyMMdd" />
        <param name="StaticLogFileName" value="true" />
        <layout type="log4net.Layout.PatternLayout,log4net">
          <param name="ConversionPattern" value="%d [%t] %-5p %c - %m%n" />
        </layout>
        <filter type="log4net.Filter.LevelRangeFilter">
          <param name="LevelMin" value="INFO" />
          <param name="LevelMax" value="INFO" />
        </filter>
      </appender>
    
      <!--错误日志-->
      <appender name="errorLog" type="log4net.Appender.RollingFileAppender,log4net" >
        <param name="File" value="logserrorerror.log" />
        <param name="AppendToFile" value="true" />
        <param name="RollingStyle" value="Date" />
        <param name="DatePattern" value="yyyyMMdd" />
        <param name="StaticLogFileName" value="true" />
        <layout type="log4net.Layout.PatternLayout,log4net">
          <param name="ConversionPattern" value="%d{yyyy-MM-dd HH:mm:ss}%newline%message%n" />
        </layout>
        <filter type="log4net.Filter.LevelRangeFilter">
          <param name="LevelMin" value="ERROR" />
          <param name="LevelMax" value="ERROR" />
        </filter>
      </appender>
      <!--警告日志-->
      <appender name="warnLog" type="log4net.Appender.RollingFileAppender,log4net" >
        <param name="File" value="logswarnwarn.log" />
        <param name="AppendToFile" value="true" />
        <param name="RollingStyle" value="Date" />
        <param name="DatePattern" value="yyyyMMdd" />
        <param name="StaticLogFileName" value="true" />
        <layout type="log4net.Layout.PatternLayout,log4net">
          <param name="ConversionPattern" value="%d{yyyy-MM-dd HH:mm:ss}%newline%message%n" />
        </layout>
        <filter type="log4net.Filter.LevelRangeFilter">
          <param name="LevelMin" value="WARN" />
          <param name="LevelMax" value="WARN" />
        </filter>
      </appender>
      <!--致命错误日志-->
      <appender name="fatalLog" type="log4net.Appender.RollingFileAppender,log4net" >
        <param name="File" value="logsfatalfatal.log" />
        <param name="AppendToFile" value="true" />
        <param name="RollingStyle" value="Date" />
        <param name="DatePattern" value="yyyyMMdd" />
        <param name="StaticLogFileName" value="true" />
        <layout type="log4net.Layout.PatternLayout,log4net">
          <param name="ConversionPattern" value="%d{yyyy-MM-dd HH:mm:ss}%newline%message%n" />
        </layout>
        <filter type="log4net.Filter.LevelRangeFilter">
          <param name="LevelMin" value="FATAL" />
          <param name="LevelMax" value="FATAL" />
        </filter>
      </appender>
    
      <appender name="LogToDB" type="log4net.Appender.AdoNetAppender">
        <bufferSize value="1" />
        <connectionType value="System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
        <connectionString value="Data Source=oa.ctitech.cn;Initial Catalog=logtest;Persist Security Info=True;User ID=sa;Password=zkx123" />
        <commandText value="INSERT INTO Log ([Date],[Thread],[Level],[Logger],[Message],[Exception]) VALUES (@log_date, @thread, @log_level, @logger, @message, @exception)" />
        <parameter>
          <parameterName value="@log_date" />
          <dbType value="DateTime" />
          <layout type="log4net.Layout.RawTimeStampLayout" />
        </parameter>
        <parameter>
          <parameterName value="@thread" />
          <dbType value="String" />
          <size value="255" />
          <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%thread" />
          </layout>
        </parameter>
        <parameter>
          <parameterName value="@log_level" />
          <dbType value="String" />
          <size value="50" />
          <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%level" />
          </layout>
        </parameter>
        <parameter>
          <parameterName value="@logger" />
          <dbType value="String" />
          <size value="255" />
          <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%logger" />
          </layout>
        </parameter>
        <parameter>
          <parameterName value="@message" />
          <dbType value="String" />
          <size value="4000" />
          <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%message" />
          </layout>
        </parameter>
        <parameter>
          <parameterName value="@exception" />
          <dbType value="String" />
          <size value="2000" />
          <layout type="log4net.Layout.ExceptionLayout" />
        </parameter>
        <!--<filter type="log4net.Filter.LevelRangeFilter">
          <param name="LevelMin" value="DEBUG" />
          <param name="LevelMax" value="FATAL" />
        </filter>-->
      </appender>
      <root>
        <level value="ALL" />
        <appender-ref ref="debugLog" />
        <appender-ref ref="infoLog"/>
        <appender-ref ref="warnLog" />
        <appender-ref ref="errorLog" />
        <appender-ref ref="fatalLog" />
        <!--<appender-ref ref="LogToDB" />-->
      </root>
      <!--
      CREATE TABLE [dbo].[Log] (
        [Id] [int] IDENTITY (1, 1) NOT NULL,
        [Date] [datetime] NOT NULL,
        [Thread] [varchar] (255) NOT NULL,
        [Level] [varchar] (50) NOT NULL,
        [Logger] [varchar] (255) NOT NULL,
        [Message] [varchar] (4000) NOT NULL,
        [Exception] [varchar] (2000) NULL
      )
      -->
    </log4net>

    三、在mvc项目中添加log4net.config

    using System;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.IO;
    using System.Reflection;
    using System.Text;
    
    namespace LogServer
    {
        public class Logger
        {
            #region Wrap common.logging
    
            static readonly Common.Logging.ILog log = Common.Logging.LogManager.GetCurrentClassLogger();
    
            public static void Debug(IFormatProvider formatProvider, Action<Common.Logging.FormatMessageHandler> formatMessageCallback, Exception exception)
            {
                log.Debug(formatProvider, formatMessageCallback, exception);
            }
    
            public static void Debug(IFormatProvider formatProvider, Action<Common.Logging.FormatMessageHandler> formatMessageCallback)
            {
                log.Debug(formatProvider, formatMessageCallback);
            }
    
            public static void Debug(Action<Common.Logging.FormatMessageHandler> formatMessageCallback, Exception exception)
            {
                log.Debug(formatMessageCallback, exception);
            }
    
            public static void Debug(Action<Common.Logging.FormatMessageHandler> formatMessageCallback)
            {
                log.Debug(formatMessageCallback);
            }
    
            public static void Debug(object message, Exception exception)
            {
                log.Debug(message, exception);
            }
    
            public static void Debug(object message)
            {
                log.Debug(message);
            }
    
            public static void DebugFormat(IFormatProvider formatProvider, string format, Exception exception, params object[] args)
            {
                log.DebugFormat(formatProvider, format, exception, args);
            }
    
            public static void DebugFormat(IFormatProvider formatProvider, string format, params object[] args)
            {
                log.DebugFormat(formatProvider, format, args);
            }
    
            public static void DebugFormat(string format, Exception exception, params object[] args)
            {
                log.DebugFormat(format, exception, args);
            }
    
            public static void DebugFormat(string format, params object[] args)
            {
                log.DebugFormat(format, args);
            }
    
            public static void Error(IFormatProvider formatProvider, Action<Common.Logging.FormatMessageHandler> formatMessageCallback, Exception exception)
            {
                log.Error(formatProvider, formatMessageCallback, exception);
            }
    
            public static void Error(IFormatProvider formatProvider, Action<Common.Logging.FormatMessageHandler> formatMessageCallback)
            {
                log.Error(formatProvider, formatMessageCallback);
            }
    
            public static void Error(Action<Common.Logging.FormatMessageHandler> formatMessageCallback, Exception exception)
            {
                log.Error(formatMessageCallback, exception);
            }
    
            public static void Error(Action<Common.Logging.FormatMessageHandler> formatMessageCallback)
            {
                log.Error(formatMessageCallback);
            }
    
            public static void Error(object message, Exception exception)
            {
                log.Error(message, exception);
            }
    
            public static void Error(object message)
            {
                log.Error(message);
            }
    
            public static void ErrorFormat(IFormatProvider formatProvider, string format, Exception exception, params object[] args)
            {
                log.ErrorFormat(formatProvider, format, exception, args);
            }
    
            public static void ErrorFormat(IFormatProvider formatProvider, string format, params object[] args)
            {
                log.ErrorFormat(formatProvider, format, args);
            }
    
            public static void ErrorFormat(string format, Exception exception, params object[] args)
            {
                log.ErrorFormat(format, exception, args);
            }
    
            public static void ErrorFormat(string format, params object[] args)
            {
                log.ErrorFormat(format, args);
            }
    
            public static void Fatal(IFormatProvider formatProvider, Action<Common.Logging.FormatMessageHandler> formatMessageCallback, Exception exception)
            {
                log.Fatal(formatProvider, formatMessageCallback, exception);
            }
    
            public static void Fatal(IFormatProvider formatProvider, Action<Common.Logging.FormatMessageHandler> formatMessageCallback)
            {
                log.Fatal(formatProvider, formatMessageCallback);
            }
    
            public static void Fatal(Action<Common.Logging.FormatMessageHandler> formatMessageCallback, Exception exception)
            {
                log.Fatal(formatMessageCallback, exception);
            }
    
            public static void Fatal(Action<Common.Logging.FormatMessageHandler> formatMessageCallback)
            {
                log.Fatal(formatMessageCallback);
            }
    
            public static void Fatal(object message, Exception exception)
            {
                log.Fatal(message, exception);
            }
    
            public static void Fatal(object message)
            {
                log.Fatal(message);
            }
    
    
            public static void FatalFormat(IFormatProvider formatProvider, string format, Exception exception, params object[] args)
            {
                log.FatalFormat(formatProvider, format, exception, args);
            }
    
            public static void FatalFormat(IFormatProvider formatProvider, string format, params object[] args)
            {
                log.FatalFormat(formatProvider, format, args);
            }
    
            public static void FatalFormat(string format, Exception exception, params object[] args)
            {
                log.FatalFormat(format, exception, args);
            }
    
            public static void FatalFormat(string format, params object[] args)
            {
                log.FatalFormat(format, args);
            }
    
            public static void Info(IFormatProvider formatProvider, Action<Common.Logging.FormatMessageHandler> formatMessageCallback, Exception exception)
            {
                log.Info(formatProvider, formatMessageCallback, exception);
            }
    
            public static void Info(IFormatProvider formatProvider, Action<Common.Logging.FormatMessageHandler> formatMessageCallback)
            {
                log.Info(formatProvider, formatMessageCallback);
            }
    
            public static void Info(Action<Common.Logging.FormatMessageHandler> formatMessageCallback, Exception exception)
            {
                log.Info(formatMessageCallback, exception);
            }
    
            public static void Info(Action<Common.Logging.FormatMessageHandler> formatMessageCallback)
            {
                log.Info(formatMessageCallback);
            }
    
            public static void Info(object message, Exception exception)
            {
                log.Info(message, exception);
            }
    
            public static void Info(object message)
            {
                log.Info(message);
            }
    
            public static void InfoFormat(IFormatProvider formatProvider, string format, Exception exception, params object[] args)
            {
                log.InfoFormat(formatProvider, format, exception, args);
            }
    
            public static void InfoFormat(IFormatProvider formatProvider, string format, params object[] args)
            {
                log.InfoFormat(formatProvider, format, args);
            }
    
            public static void InfoFormat(string format, Exception exception, params object[] args)
            {
                log.InfoFormat(format, exception, args);
            }
    
            public static void InfoFormat(string format, params object[] args)
            {
                log.InfoFormat(format, args);
            }
    
            public bool IsDebugEnabled
            {
                get { return IsDebugEnabled; }
            }
    
            public bool IsErrorEnabled
            {
                get { return IsErrorEnabled; }
            }
    
            public bool IsFatalEnabled
            {
                get { return IsFatalEnabled; }
            }
    
            public bool IsInfoEnabled
            {
                get { return IsInfoEnabled; }
            }
    
            public bool IsTraceEnabled
            {
                get { return IsTraceEnabled; }
            }
    
            public bool IsWarnEnabled
            {
                get { return IsWarnEnabled; }
            }
    
            public static void Trace(IFormatProvider formatProvider, Action<Common.Logging.FormatMessageHandler> formatMessageCallback, Exception exception)
            {
                log.Trace(formatProvider, formatMessageCallback, exception);
            }
    
            public static void Trace(IFormatProvider formatProvider, Action<Common.Logging.FormatMessageHandler> formatMessageCallback)
            {
                log.Trace(formatProvider, formatMessageCallback);
            }
    
            public static void Trace(Action<Common.Logging.FormatMessageHandler> formatMessageCallback, Exception exception)
            {
                log.Trace(formatMessageCallback, exception);
            }
    
            public static void Trace(Action<Common.Logging.FormatMessageHandler> formatMessageCallback)
            {
                log.Info(formatMessageCallback);
            }
    
            public static void Trace(object message, Exception exception)
            {
                log.Info(message, exception);
            }
    
            public static void Trace(object message)
            {
                log.Info(message);
            }
    
            public static void TraceFormat(IFormatProvider formatProvider, string format, Exception exception, params object[] args)
            {
                log.InfoFormat(formatProvider, format, exception, args);
            }
    
            public static void TraceFormat(IFormatProvider formatProvider, string format, params object[] args)
            {
                log.InfoFormat(formatProvider, format, args);
            }
    
            public static void TraceFormat(string format, Exception exception, params object[] args)
            {
                log.InfoFormat(format, exception, args);
            }
    
            public static void TraceFormat(string format, params object[] args)
            {
                log.InfoFormat(format, args);
            }
    
            public static void Warn(IFormatProvider formatProvider, Action<Common.Logging.FormatMessageHandler> formatMessageCallback, Exception exception)
            {
                log.Warn(formatProvider, formatMessageCallback, exception);
            }
    
            public static void Warn(IFormatProvider formatProvider, Action<Common.Logging.FormatMessageHandler> formatMessageCallback)
            {
                log.Warn(formatProvider, formatMessageCallback);
            }
    
            public static void Warn(Action<Common.Logging.FormatMessageHandler> formatMessageCallback, Exception exception)
            {
                log.Warn(formatMessageCallback, exception);
            }
    
            public static void Warn(Action<Common.Logging.FormatMessageHandler> formatMessageCallback)
            {
                log.Warn(formatMessageCallback);
            }
    
            public static void Warn(object message, Exception exception)
            {
                log.Warn(message, exception);
            }
    
            public static void Warn(object message)
            {
                log.Warn(message);
            }
    
            public static void WarnFormat(IFormatProvider formatProvider, string format, Exception exception, params object[] args)
            {
                log.WarnFormat(formatProvider, format, exception, args);
            }
    
            public static void WarnFormat(IFormatProvider formatProvider, string format, params object[] args)
            {
                log.WarnFormat(formatProvider, format, args);
            }
    
            public static void WarnFormat(string format, Exception exception, params object[] args)
            {
                log.WarnFormat(format, exception, args);
            }
    
            public static void WarnFormat(string format, params object[] args)
            {
                log.WarnFormat(format, args);
            }
    
            #endregion
    
            #region logger with Diagnostics
    
            public static void TraceReflect(params string[] args)
            {
                try
                {
                    StackFrame frame = new StackFrame(1);
                    MethodBase method = frame.GetMethod();
                    StackFrame frame2 = new StackFrame(2);
                    MethodBase method2 = frame2.GetMethod();
                    List<string> list = new List<string>();
                    if (method.DeclaringType != null)
                    {
                        string format = GetReflectLogFormat(args, method.DeclaringType.ToString(), method2.Name + "/" + method.Name, ref list);
                        Logger.TraceFormat(format, list.ToArray());
                    }
                }
                catch { }
            }
    
            /// <summary>
            /// 记录出错日志
            /// </summary>
            /// <param name="args">第一个参数默认为错误描述</param>
            public static void ErrorReflect(params string[] args)
            {
                try
                {
                    StackFrame frame = new StackFrame(1);
                    MethodBase method = frame.GetMethod();
                    List<string> list = new List<string>();
                    if (method.DeclaringType != null)
                    {
                        string format = GetReflectErrorFormat(args, method.DeclaringType.ToString(), method.Name, ref list);
                        Logger.ErrorFormat(format, list.ToArray());
                    }
                }
                catch { }
            }
    
            public static void DebugReflect(params string[] args)
            {
                try
                {
                    StackFrame frame = new StackFrame(1);
                    MethodBase method = frame.GetMethod();
                    StackFrame frame2 = new StackFrame(2);
                    MethodBase method2 = frame2.GetMethod();
                    List<string> list = new List<string>();
                    if (method.DeclaringType != null)
                    {
                        string format = GetReflectLogFormat(args, method.DeclaringType.ToString(),
                                                            method2.Name + "/" + method.Name, ref list);
                        Logger.DebugFormat(format, list.ToArray());
                    }
                }
                catch { }
            }
    
            public static void FatalReflect(params string[] args)
            {
                try
                {
                    StackFrame frame = new StackFrame(1);
                    MethodBase method = frame.GetMethod();
                    List<string> list = new List<string>();
                    if (method.DeclaringType != null)
                    {
                        string format = GetReflectLogFormat(args, method.DeclaringType.ToString(), method.Name, ref list);
                        Logger.FatalFormat(format, list.ToArray());
                    }
                }
                catch { }
            }
    
            public static void InfoReflect(params string[] args)
            {
                try
                {
                    StackFrame frame = new StackFrame(1);
                    MethodBase method = frame.GetMethod();
                    StackFrame frame2 = new StackFrame(2);
                    MethodBase method2 = frame2.GetMethod();
                    List<string> list = new List<string>();
                    if (method.DeclaringType != null)
                    {
                        string format = GetReflectLogFormat(args, method.DeclaringType.ToString(),
                                                            method2.Name + "/" + method.Name, ref list);
                        Logger.InfoFormat(format, list.ToArray());
                    }
                }
                catch { }
            }
    
            /// <summary>
            /// 获取错误日志的模板
            /// </summary>
            /// <param name="parms"></param>
            /// <param name="classname"></param>
            /// <param name="methodname"></param>
            /// <param name="argelist"></param>
            /// <returns></returns>
            /// <summary>
            private static string GetReflectErrorFormat(string[] parms, string classname, string methodname, ref List<string> argelist)
            {
                argelist.Add(classname);
                argelist.Add(methodname);
                StringBuilder sb = new StringBuilder("方法:{0}.{1}
    ");
                int l = parms.Length;
                if (l > 0)
                {
                    sb.Append("错误:{2}
    ");
                    argelist.Add(parms[0]);
                    if (l > 1)
                    {
                        sb.Append("参数:");
                        for (int i = 1; i < l; i++)
                        {
                            sb.Append("[{" + (i + 2) + "}],");
                            argelist.Add(parms[i]);
                        }
                    }
                }
                return sb.ToString().TrimEnd(',');
            }
    
            /// <summary>
            /// 获取调试信息的模板
            /// </summary>
            /// <param name="parms"></param>
            /// <param name="classname"></param>
            /// <param name="methodname"></param>
            /// <param name="argelist"></param>
            /// <returns></returns>
            private static string GetReflectLogFormat(string[] parms, string classname, string methodname, ref List<string> argelist)
            {
                argelist.Add(classname);
                argelist.Add(methodname);
                StringBuilder sb = new StringBuilder("方法:{0}.{1}
    ");
                int l = parms.Length;
                if (l > 0)
                {
                    sb.AppendFormat("参数:");
                    for (int i = 0; i < l; i++)
                    {
                        sb.Append("[{" + (i + 2) + "}],");
                        argelist.Add(parms[i]);
                    }
                }
                return sb.ToString().TrimEnd(',');
            }
            #endregion
    
        }
    
    
        public class Log4NetPathPattern : log4net.Util.PatternConverter
        {
            protected override void Convert(System.IO.TextWriter writer, object state)
            {
                try
                {
                    var dirstr = System.Configuration.ConfigurationManager.AppSettings["log4net:root"];
                    if (string.IsNullOrWhiteSpace(dirstr)) dirstr = "logs";
                    dirstr = dirstr.TrimStart('/', '\', '~');
                    if (!Path.IsPathRooted(dirstr)) dirstr = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, dirstr);
                    writer.Write(dirstr);
                    //如果在本项目中用,可以把文件夹加上程序集名:Assembly.GetExecutingAssembly()
                    //否则只有在配置文件中加项目名了
                }
                catch
                {
                    //出错则默认当前目录logs文件夹
                    writer.Write(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "logs"));
                }
    
            }
        }
    }

    四、在web.config的<configSections>内部添加

     <sectionGroup name="common">
          <section name="logging" type="Common.Logging.ConfigurationSectionHandler, Common.Logging" />
        </sectionGroup>

    五、在web.config的</configSections>的后面添加

    <common>
        <logging>
          <factoryAdapter type="Common.Logging.Log4Net.Log4NetLoggerFactoryAdapter, Common.Logging.Log4net">
            <arg key="configType" value="FILE-WATCH" />
            <!-- FILE,FILE-WATCH,INLINE,EXTERNAL-->
            <arg key="configFile" value="~/log4net.config" />
            <arg key="level" value="ALL" />
          </factoryAdapter>
        </logging>
      </common>

    六、创建测试类Class1进行调用所有类结构如下图

  • 相关阅读:
    Docker安装Zookeeper并进行操作
    JVM 完整深入解析
    synchronized关键字加到static静态方法和非static静态方法区别
    submit与execute区别
    ThreadPoolTaskExecutor和ThreadPoolExecutor区别
    Redis占用内存大小
    Java中CycliBarriar和CountdownLatch区别
    Java并发编程:线程间协作的两种方式:wait、notify、notifyAll和Condition
    文本格式
    JavaScript事件
  • 原文地址:https://www.cnblogs.com/srfree/p/3513397.html
Copyright © 2020-2023  润新知