用输出重定向符号> 即可，格式如下：
shell命令 >/dev/null

若要将标准错误输出也一并重定向，如下:
shell命令 >/dev/null 2>&1
这样就不管命令执行成功还是失败，都不会有任何信息打印到屏幕
 
转载于:https://www.cnblogs.com/mingzhang/p/7680673.html

控制台输出日志
 
先引入maven依赖
 
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.25</version>
</dependency>
 
然后在使用日志的类中创建logger全局变量
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public Logger logger = LoggerFactory.getLogger(TestController.class);
 
然后就可以使用logger.info、logger.error等在控制台输出日志了
 
logger.info("测试输出日志");
logger.error(e.toString(), e);
 
 
 
输出日志文件到本地
 
首先，在application.yml中配置日志输出
 
logging:
  file: mylogs.log
  path: D:/SuperMapDataLogs/mylogs
 
如果就这样，那么本地是不会出现相关的日志文件的,接下来，就是要在xml中配置logging.path
 
我们在src/main/resources中创建一个logback-spring.xml，注意：-spring在application之后可以扫描到，如果只写logback.xml那么该xml就会优先于application.yml进行扫描，因此无效
 
logback-spring.xml(修改后面的包名即可)
 
<?xml version="1.0" encoding="UTF-8"?>
<!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出 -->
<!-- scan:当此属性设置为true时，配置文档如果发生改变，将会被重新加载，默认值为true -->
<!-- scanPeriod:设置监测配置文档是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。
                 当scan为true时，此属性生效。默认的时间间隔为1分钟。 -->
<!-- debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->
<configuration  scan="true" scanPeriod="10 seconds">
    <contextName>logback-spring</contextName>

    <!-- name的值是变量的名称，value的值时变量定义的值。通过定义的值会被插入到logger上下文中。定义后，可以使“${}”来使用变量。 -->
    <property name="logging.path" value="D:/SuperMapDataLogs/mylogs" />

    <!--0. 日志格式和颜色渲染 -->
    <!-- 彩色日志依赖的渲染类 -->
    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
    <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
    <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
    <!-- 彩色日志格式 -->
    <property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>

    <!--1. 输出到控制台-->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <!--此日志appender是为开发使用，只配置最底级别，控制台输出的日志级别是大于或等于此级别的日志信息-->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>debug</level>
        </filter>
        <encoder>
            <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>
            <!-- 设置字符集 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!--2. 输出到文档-->
    <!-- 2.1 level为 DEBUG 日志，时间滚动输出  -->
    <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${logging.path}/web_debug.log</file>
        <!--日志文档输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 日志归档 -->
            <fileNamePattern>${logging.path}/web-debug-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录debug级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>debug</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 2.2 level为 INFO 日志，时间滚动输出  -->
    <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${logging.path}/web_info.log</file>
        <!--日志文档输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 每天日志归档路径以及格式 -->
            <fileNamePattern>${logging.path}/web-info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录info级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>info</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 2.3 level为 WARN 日志，时间滚动输出  -->
    <appender name="WARN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${logging.path}/web_warn.log</file>
        <!--日志文档输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${logging.path}/web-warn-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录warn级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>warn</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 2.4 level为 ERROR 日志，时间滚动输出  -->
    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${logging.path}/web_error.log</file>
        <!--日志文档输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${logging.path}/web-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录ERROR级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!--
        <logger>用来设置某一个包或者具体的某一个类的日志打印级别、
        以及指定<appender>。<logger>仅有一个name属性，
        一个可选的level和一个可选的addtivity属性。
        name:用来指定受此logger约束的某一个包或者具体的某一个类。
        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
              还有一个特俗值INHERITED或者同义词NULL，代表强制执行上级的级别。
              如果未设置此属性，那么当前logger将会继承上级的级别。
        addtivity:是否向上级logger传递打印信息。默认是true。
        <logger name="org.springframework.web" level="info"/>
        <logger name="org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor" level="INFO"/>
    -->

    <!--
        使用mybatis的时候，sql语句是debug下才会打印，而这里我们只配置了info，所以想要查看sql语句的话，有以下两种操作：
        第一种把<root level="info">改成<root level="DEBUG">这样就会打印sql，不过这样日志那边会出现很多其他消息
        第二种就是单独给dao下目录配置debug模式，代码如下，这样配置sql语句会打印，其他还是正常info级别：
        【logging.level.org.mybatis=debug logging.level.dao=debug】
     -->

    <!--
        root节点是必选节点，用来指定最基础的日志输出级别，只有一个level属性
        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
        不能设置为INHERITED或者同义词NULL。默认是DEBUG
        可以包含零个或多个元素，标识这个appender将会添加到这个logger。
    -->

    <!-- 4. 最终的策略 -->
    <!-- 4.1 开发环境:打印控制台-->
    <springProfile name="dev">
        <logger name="com.supermap.controller" level="debug"/><!-- 修改此处扫描包名 -->
    </springProfile>

    <root level="info">
        <appender-ref ref="CONSOLE" />
        <appender-ref ref="DEBUG_FILE" />
        <appender-ref ref="INFO_FILE" />
        <appender-ref ref="WARN_FILE" />
        <appender-ref ref="ERROR_FILE" />
    </root>

    <!-- 4.2 生产环境:输出到文档
    <springProfile name="pro">
        <root level="info">
            <appender-ref ref="CONSOLE" />
            <appender-ref ref="DEBUG_FILE" />
            <appender-ref ref="INFO_FILE" />
            <appender-ref ref="ERROR_FILE" />
            <appender-ref ref="WARN_FILE" />
        </root>
    </springProfile> -->
</configuration>
 
下面对日志结构进行说明：
 
（1）FILE_LOG_PATTERN：日志输出格式变量，在控制台输出和文件中输出的append中都引用了此变量。
 
（2）consoleLog：定义一个控制台的appender
 
（3）fileLog：定义一个日志文件的appender，这就是文件输出的详细配置，<File>是日志文件的输出地址：必须要为${LOG_PATH}/${LOG_FILE}，这样我们在application.properties中的配置才有效。level标签：如果我们设置了level为info,只会输出info的日志信息，其他日志级别的日志就会过滤掉，建议不配置level属性。
 
（4）logger：其name就是项目中对应的包路径，appender-ref是appender的引用，在本配置文件中，意思就是com.example.xyx.MySpringBootTest包下文件的日志，按照fileLog的配置去输出，即按照FILE_LOG_PATTERN的格式，输出到D:/data/mylog/myLog.log文件中。标签level="debug"是设置日志级别：作用是debug级别及其以上级别的日志会输出（debug、info、warn、error,,,），注意此处的level是一个下线，比其日志级别高的日志信息也会输出，很重要。additivity="false"是配置此logger是否提交给其他的logger或者root节点，如果true，则root也会执行或者其他的可以拦截到的logger节点,且logger的level优先级高;否则不会执行，在本配置文件中即控制台不会输出com.example.xyx.MySpringBootTest包下文件的日志。
 
（5）root：根节点，在logback-spring.xml中只引用了控制台日志输出配置，不会输出到文件，如果想输出到文件，可以写再写一个引用。level=info，在控制台输出into级别及其以上级别的日志。会拦截所有包下的日志，但是其输出会受到logger的影响，即注意logger中的additivity属性，如果为false，com.example.xyx.MySpringBootTest包下的日志不会输出到控制台。
 
配置完成之后，下面进行演示：
 
      启动项目，刷新项目，此时多了一个文件夹
 
 
打开本地路径application.yml中配置的输出路径，此时多了一个文件夹
 
 
打开文件查看日志，看到日志生成成功
 
 
 
 
 
 
 
 
 

django线上环境中的日志输出是相当重要的，它可以将所有的错误、警告、调试等重要信息全部输出到日志，这样便于维护和排查问题。 
 接下来本文会详细的介绍django logging配置，以及这些配置的含义与作用。 
 用到的东西，本文也会尽量详细的解答： 
 首先先来看看实际中配置：配置settings.py
 
写在最前
 
python manage.py runserver >> /home/aea/log/test.log 表示运行django时将console全部重定向到/home/aea/log/test.log
 
注意：这时你的django控制台的打印会一直是空白，因为已经全部重定向到/home/aea/log/test.log文件，，推荐在生产环境中使用，并关闭debug
 
保证你配置的所有log文件地址正确且文件存在，否则会报错！
 
DEBUG = False  #线上环境时要关闭debug
ALLOWED_HOSTS = ['*']   #线上环境时要允许所有ip访问，或有自己的规则

#下面就是logging的配置
LOGGING = {
    'version': 1,  # 指明dictConnfig的版本，目前就只有一个版本，哈哈
    'disable_existing_loggers': False,  # 表示是否禁用所有的已经存在的日志配置
    'formatters': {  # 格式器
        'verbose': {  # 详细
            'format': '%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s'
        },
        'standard': {  # 标准
            'format': '[%(asctime)s] [%(levelname)s] %(message)s'
        },
    },
    # handlers：用来定义具体处理日志的方式，可以定义多种，"default"就是默认方式，"console"就是打印到控制台方式。file是写入到文件的方式，注意使用的class不同
    'handlers': { # 处理器，在这里定义了两个个处理器
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',
            'stream': 'ext://sys.stdout',   # 文件重定向的配置，将打印到控制台的信息都重定向出去 python manage.py runserver >> /home/aea/log/test.log
            # 'stream': open('/home/aea/log/test.log','a'),  #虽然成功了，但是并没有将所有内容全部写入文件，目前还不清楚为什么
            'formatter': 'standard'   # 制定输出的格式，注意 在上面的formatters配置里面选择一个，否则会报错
        },
        'file': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',
            'filename': '/home/aea/log/jwt_test.log',  #这是将普通日志写入到日志文件中的方法，
            'formatter': 'standard'
        },
        'default': {
            'level':'DEBUG',
            'class':'logging.handlers.RotatingFileHandler',
            'filename': '/home/aea/log/all.log',     #日志输出文件
            'maxBytes': 1024*1024*5,                  #文件大小
            'backupCount': 5,                         #备份份数
            'formatter':'standard',                   #使用哪种formatters日志格式
        },
        # 上面两种写入日志的方法是有区别的，前者是将控制台下输出的内容全部写入到文件中，这样做的好处就是我们在views代码中的所有print也会写在对应的位置
        # 第二种方法就是将系统内定的内容写入到文件，具体就是请求的地址、错误信息等，小伙伴也可以都使用一下然后查看两个文件的异同。
    },
    'loggers': {  # log记录器，配置之后就会对应的输出日志
        # django 表示就是django本身默认的控制台输出，就是原本在控制台里面输出的内容，在这里的handlers里的file表示写入到上面配置的file-/home/aea/log/jwt_test.log文件里面
        # 在这里的handlers里的console表示写入到上面配置的console-/home/aea/log/test.log文件里面
        'django': {
            'handlers': ['console','file'],
            # 这里直接输出到控制台只是请求的路由等系统console，当使用重定向之后会把所有内容输出到log日志
            'level': 'DEBUG',
            'propagate': True,
        },
        'django.request ':{
            'handlers': ['console','file'],
            'level': 'WARNING',  # 配合上面的将警告log写入到另外一个文件
            'propagate': True,
        },
        'django.db.backends': {
            'handlers': ['file'], # 指定file handler处理器，表示只写入到文件
            'level':'DEBUG',
            'propagate': True,
        },
    },
}
 
下面是对参数和配置的解释
 
level:级别
 
一个记录器是日志系统的一个实体，每一个记录器是一个已经命名好的可以将消息为进程写入的“桶”。 
 每一个记录器都会有一个日志等级，每个等级描述了记录器即将处理的信息的严重性，python定义了以下六个等级： 
 级别 值 描述 
 CRITICAL 50 关键错误/消息,描述已经发生的严重问题 
 ERROR 40 错误,描述已经发生的主要问题 
 WARNING 30 警告消息,描述已经发生的小问题 
 INFO 20 通知消息,普通的系统信息列表内容 
 DEBUG 10 调试,出于调试目的的低层次系统信息 
 NOTSET 0 无级别
 
处理器/记录器 关键字参数：
 
关键字参数 描述 
 filename 将日志消息附加到指定文件名的文件 
 filemode 指定用于打开文件模式, 文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。 
 format 用于生成日志消息的格式字符串 
 datefmt 用于输出日期和时间的格式字符串 
 level 设置记录器的级别 
 propagate 可以基于每个记录器控制该传播。 如果您不希望特定记录器传播到其父项，则可以关闭此行为。 
 stream 提供打开的文件，用于把日志消息发送到文件。可以指定输出到sys.stderr,sys.stdout或者文件，默认为sys.stderr。 
 若同时列出了filename和stream两个参数，则stream参数会被忽略。
 
format: 日志消息格式
 
格式 描述 
 %(name)s 记录器的名称 
 %(levelno)s 数字形式的日志记录级别 
 %(levelname)s 日志记录级别的文本名称 
 %(filename)s 执行日志记录调用的源文件的文件名称 
 %(pathname)s 执行日志记录调用的源文件的路径名称 
 %(funcName)s 执行日志记录调用的函数名称 
 %(module)s 执行日志记录调用的模块名称 
 %(lineno)s 执行日志记录调用的行号 
 %(created)s 执行日志记录的时间 
 %(asctime)s 日期和时间 
 %(msecs)s 毫秒部分 
 %(thread)d 线程ID 
 %(threadName)s 线程名称 
 %(process)d 进程ID 
 %(message)s 记录的消息
 
内置处理器
 
logging模块提供了一些处理器，可以通过各种方式处理日志消息。使用addHandler()方法将这些处理器添加给Logger对象。另外还可以为每个处理器配置它自己的筛选和级别。 
 logging.StreamHandler 可以向类似与sys.stdout或者sys.stderr的任何文件对象(file object)输出信息 
 logging.FileHandler 将日志消息写入文件filename。 
 logging.handlers.DatagramHandler(host，port) 发送日志消息给位于制定host和port上的UDP服务器。使用UDP协议，将日志信息发送到网络 
 logging.handlers.HTTPHandler(host, url) 使用HTTP的GET或POST方法将日志消息上传到一台HTTP 服务器。 
 logging.handlers.RotatingFileHandler(filename) 将日志消息写入文件filename。如果文件的大小超出maxBytes制定的值，那么它将被备份为filenamel。 
 logging.handlers.SocketHandler 使用TCP协议，将日志信息发送到网络。 
 logging.handlers.SysLogHandler 日志输出到syslog 
 logging.handlers.NTEventLogHandler 远程输出日志到Windows NT/2000/XP的事件日志 
 logging.handlers.SMTPHandler 远程输出日志到邮件地址 
 logging.handlers.MemoryHandler 日志输出到内存中的制定buffer 
 注意：由于内置处理器还有很多，如果想更深入了解。可以查看官方手册。
 
django提供的内置记录器
 
django 在Django层次结构中的所有消息记录器。没有使用此名称发布消息，而是使用下面的记录器之一。 
 django.request 与请求处理相关的日志消息。5xx响应被提升为错误消息；4xx响应被提升为警告消息。 
 django.server 与由RunServer命令调用的服务器所接收的请求的处理相关的日志消息。HTTP 5XX响应被记录为错误消息，4XX响应被记录为警告消息，其他一切都被记录为INFO。 
 django.template 与模板呈现相关的日志消息 
 django.db.backends 有关代码与数据库交互的消息。例如，请求执行的每个应用程序级SQL语句都在调试级别记录到此记录器。
 
部署生产环境建议使用的方法
 
很多时候我们在代码中会增加很多print 来打印一些调试和测试的内容，默认情况下这些内容全部打印在控制台。 
 问题是生产环境上，进程都是后台运行的，所有我们可以使用，将控制台打印的所有内容全部重定向到日志文件即可。 
 参考我上面的配置，在console的handler中配置了‘stream’: ‘ext://sys.stdout’, 
 它会将我们的控制台输出全部重定向写入到文件中去。 
 命令是： 
 这条命令含义是：在后台运行进程，并将所有的控制台输出全部重定向到文件
 
nohup python manage.py runserver >>/home/aea/log/test.log &

需求是把某一类的日志单独输出到某个文件中，以达到某一类的操作，对应相应的日志文件。
 
而不是都混在一起，查日志也不方便。
 比如，修改用户的操作，记录到一个叫userOperateLog.log文件中。错误日志，比如空指针啥的，记录到production.log文件。

 这样，日志看起来就显得有条理些。

 
下面是log4j相关的内容，先了解一下，然后，再看需求，就很有帮助啦。
 

 
 
输出级别的种类
 
 
 
OFF 	为最高等级 关闭了日志信息  
FATAL  	为可能导致应用中止的严重事件错误  
ERROR 	为严重错误 主要是程序的错误  
WARN 	为一般警告，比如session丢失  
INFO 	为一般要显示的信息，比如登录登出  
DEBUG 	为程序的调试信息  
TRACE 	为比DEBUG更细粒度的事件信息  
ALL 	为最低等级，将打开所有级别的日志 

 
配置日志信息输出目的地

 
 
 
 1.org.apache.log4j.ConsoleAppender（控制台）  
 2.org.apache.log4j.FileAppender（文件）  
 3.org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）  
 4.org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件）  
 5.org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）

 
配置日志信息的格式

 
 
 
 1.org.apache.log4j.HTMLLayout（以HTML表格形式布局），  
 2.org.apache.log4j.PatternLayout（可以灵活地指定布局模式），  
 3.org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），  
 4.org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）

 
日志信息格式中几个符号所代表的含义：

 
 
 
-X号: X信息输出时左对齐；  
%p: 输出日志信息优先级，即DEBUG，INFO，WARN，ERROR，FATAL,  
%d: 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss,SSS}，输出类似：2002年10月18日 22：10：28，921  
%r: 输出自应用启动到输出该log信息耗费的毫秒数  
%c: 输出日志信息所属的类目，通常就是所在类的全名  
%t: 输出产生该日志事件的线程名  
%l: 输出日志事件的发生位置，相当于%C.%M(%F:%L)的组合,包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main (TestLog4.java:10)  
%x: 输出和当前线程相关联的NDC(嵌套诊断环境),尤其用到像java servlets这样的多客户多线程的应用中。  
%%: 输出一个"%"字符  
%F: 输出日志消息产生时所在的文件名称  
%L: 输出代码中的行号  
%m: 输出代码中指定的消息,产生的日志具体信息  
%n: 输出一个回车换行符，Windows平台为"/r/n"，Unix平台为"/n"输出日志信息换行  
可以在%与模式字符之间加上修饰符来控制其最小宽度、最大宽度、和文本的对齐方式。如：  
1)%20c：指定输出category的名称，最小的宽度是20，如果category的名称小于20的话，默认的情况下右对齐。  
2)%-20c:指定输出category的名称，最小的宽度是20，如果category的名称小于20的话，"-"号指定左对齐。  
3)%.30c:指定输出category的名称，最大的宽度是30，如果category的名称大于30的话，就会将左边多出的字符截掉，但小于30的话也不会有空格。  
4)%20.30c:如果category的名称小于20就补空格，并且右对齐，如果其名称长于30字符，就从左边较远输出的字符截掉。 

 有了上面的一些基础之后，下面看，我们项目里面使用的log4j.xml的配置文件。 
 
 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration PUBLIC "-//APACHE//DTD LOG4J 1.2//EN" "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

	<!-- Appenders 日志信息输出目的地 -->
	
	<!-- ConsoleAppender -->
	<!-- 每个ConsoleAppender都有一个target，表示它的输出目的地。 -->
	<!-- 它可以是System.out，标准输出设备（缓冲显示屏） -->
	<!-- 或者是System.err，标准错误设备（不缓冲显示屏） -->
	<appender name="console" class="org.apache.log4j.ConsoleAppender">
		<param name="Target" value="System.out" />
		<layout class="org.apache.log4j.PatternLayout">
			<param name="ConversionPattern" value="%d %-5p: %c - %m%n" />
		</layout>
	</appender>
	
	<!-- RollingFileAppender 回滚文件 -->
	<!-- Append true，默认每次启动系统，日志继续输出到原来的文件，而不是清空了再来 -->
	<!-- MaxFileSize 后缀可以是KB, MB 或者是 GB. 在日志文件到达该大小时，将会自动滚动，即将原来的内容移到mylog.log.1文件 -->
	<!-- MaxBackupIndex 最多20个 -->
	<!-- PatternLayout 控制日志输出的格式化，参考上面的那些符合说明，自己怼自己想要的格式。 -->
	<!-- filter 级别范围过滤器 -->
	<!-- levelMin levelMax 范围 -->
	<appender name="StreamOperateFile" class="org.apache.log4j.RollingFileAppender">
		<param name="File" value="f:/ezLog/streamOperate.log" />
		<param name="Append" value="true"/>
		<param name="MaxFileSize" value="10MB"/>
		<param name="MaxBackupIndex" value="20"/>  
		<layout class="org.apache.log4j.PatternLayout">
			<param name="ConversionPattern" value="%m%n" />
		</layout>
		<filter class="org.apache.log4j.varia.LevelRangeFilter">
			<param name="levelMin" value="INFO" />
			<param name="levelMax" value="INFO" />
			<param name="AcceptOnMatch" value="true" />
		</filter>  
	</appender>
	
	<!-- 同上 回滚文件，有2个的原因就是演示，把不同的日志输出到不同的文件 -->
	<appender name="File" class="org.apache.log4j.RollingFileAppender">
		<param name="File" value="f:/ezLog/production.log" />
		<param name="Append" value="true"/>
		<param name="MaxFileSize" value="10MB"/>
		<param name="MaxBackupIndex" value="20"/>  
		<layout class="org.apache.log4j.PatternLayout">
			<param name="ConversionPattern" value="%d %-5p: %c - %m%n" />
		</layout>
	</appender>

	<!-- 下面这些就是根据 这些路径来控制对应包下的文件的日志输出级别，基本上都是报错了，才输出日志-->
	<logger name="org.springframework.core">
		<level value="error" />
	</logger>
	
	<logger name="org.springframework.beans">
		<level value="error" />
	</logger>
	
	<logger name="org.springframework.context">
		<level value="error" />
	</logger>

	<logger name="org.springframework.http">
		<level value="error" />
	</logger>

	<logger name="org.springframework.web">
		<level value="error" />
	</logger>
	
	<logger name="org.elasticsearch.client.transport">
		<level value="debug" />
	</logger>
	
	<logger name="org.springframework.data.mongodb">
		<level value="error" />
	</logger>
	
	<!-- 这个就是自定义的一个logger -->
	<!-- 输出级别是info级别及以上的日志，不要怕，StreamOperateFile已经过滤，只输出info级别的日志 -->
	<!-- additivity 这个默认是true，即继承父类 root logger -->
	<!-- 也就是说，你的这个日志也会在root的logger里面输出的，我这里配置false，就是不继承，各走各的。 -->
	<!-- appender-ref 也就是说这个logger的输出目的地是哪里，ref就是关联到上面声明的一个file，一个console -->
	<logger name="StreamOperateFile" additivity="false">
		<level value="info" />
		<appender-ref ref="StreamOperateFile" />
		<appender-ref ref="console" />
	</logger>
	
	<!-- 传说中的根logger -->
	<!-- 输出级别是info级别及以上的日志，下面的ref关联的两个appender没有filter设置，所以，info及以上的日志都是会输出到这2个appender的 -->
	<root>
		<priority value="info" />
		<appender-ref ref="console" />
		<appender-ref ref="File" />
	</root>
	
</log4j:configuration>


 在代码里面使用就如下：

 private static final Logger STREAM_OPERATE_LOG = LoggerFactory.getLogger("StreamOperateFile");

 STREAM_OPERATE_LOG.info("你要输出的日志信息");

 getLogger("StreamOperateFile")的参数和你配置的那个要对应。

 
 

 
 
最后，真的在配置的地方生成了2个不同的日志文件，而且内容是不重叠的，各自是各自的。