java程序日志管理

初入软件开发这一行的人，可能对日志管理的概念并不是很明确，大概是由于经验所限，以至于根本还考虑不到这个问题。
而从某种意义上来说，日志管理实际上也不需要初入这一行的人来管，他们只需要负责实现自己的主要业务逻辑和功能就好了。
我当初刚入行的时候就有很长一段时间完全不用去关心日志，到后来偶尔涉及到的时候，也都是从其他地方采用cv大法直接搬用。
不过，随着工作时间的变化，随着手头上任务重要程度的变化，也随着接触到的项目数量的变化，让我越来越意识到日志的重要性，它在整个系统中发挥着至关重要的作用！
尤其是涉及到需要后期维护的项目，更是经常需要依靠日志来定位问题，可以说他是运行中的项目出问题时，找问题最好的手段。
java中日志管理的技术有很多，像java自身的java.util.logging，apache的commons-logging，以及slf4j、log4j、logback等等。
其中java.util.logging在日常开发中用的不是很多，用的比较多的后边四个，commons-logging和slf4j是接口，log4j和logback是具体的实现，在我所接触的项目中就用到了这几个。
因为java推荐的就是面向接口编程，所以一般推荐使用的就是那两个接口，但是又由于commons-logging的动态绑定造成了一些问题，因此这两个里边又推荐使用slf4j。
同样的，在两种实现中，logback和log4j是由同一个作者开发，logback出现的更晚，更好，因为也就更推荐用logback。
那么综上而言，目前最推荐的java中的日志管理，就是使用slf4j+logback。
实际上，说了这么多，真正用起来是很简单的，只需要导入相关jar包，写好相关配置，然后需要的地方调用就好了，学习的过程中为了比较不同，我也写了一个简单的额例子。
因为目前大部分的项目都是maven管理，spring框架，所以这个例子中也算是顺便联系spring的最基础配置，就也用了spring。
maven的导包配置pom.xml如下，为了比较这四项技术，所以相关的包我全都导了进来，commons-logging是其他jar依赖的，所以便没有手动再导一次：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>logTest</groupId>
  <artifactId>logTest</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>logTest Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>4.0.3.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.0.3.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.12</version>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-core</artifactId>
        <version>1.1.2</version>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.1.2</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.7</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>jcl-over-slf4j</artifactId>
        <version>1.7.12</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>logTest</finalName>
  </build>
</project>

然后写了简单的spring.xml配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context-3.0.xsd"  >

    <!-- 引入属性文件 -->
    <!-- --> 
    <context:property-placeholder location="classpath:log4j.properties" ignore-unresolvable="true" />

    <!-- 配置spring注解扫描 -->
  <context:component-scan base-package="logService.service.impl" />
</beans>

很简单，就是配置引入配置文件和spring装配扫描路径，然后是两个不同的日志配置文件，从命名就很容易知道哪个对应的是哪个，首先是log4j.properties:

`log4j.properties：
log4j.rootLogger=WARN, CONSOLE, FILE  
## for console  
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender  
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout  
log4j.appender.CONSOLE.layout.ConversionPattern=%d{MM-ddHH:mm:ss}[%c-%L][%t][%-4r] - %m%n  
log4j.appender.CONSOLE.Encoding=utf-8
## for file  
log4j.appender.FILE=org.apache.log4j.RollingFileAppender  
log4j.appender.FILE.File=C:/Users/Think/Desktop/log4j.log 
log4j.appender.FILE.MaxFileSize=1MB  
log4j.appender.FILE.Append = true  
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout  
log4j.appender.FILE.layout.ConversionPattern=%d{yyyy-MM-ddHH\:mm\:ss} [%t] %-5p  %-4r %x - %m%n
log4j.appender.FILE.Encoding=utf-8`

然后是logback.xml:

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">
<!--定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径-->
<property name="LOG_HOME" value="C:/Users/Think/Desktop" />
<!-- 控制台输出 -->
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
</encoder>
</appender>
<!-- 按照每天生成日志文件 -->
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!--日志文件输出的文件名-->
<FileNamePattern>${LOG_HOME}/logback.%d{yyyy-MM-dd}.log</FileNamePattern>
<!--日志文件保留天数-->
<MaxHistory>30</MaxHistory>
</rollingPolicy>
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
</encoder>
<!--日志文件最大的大小-->
<triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
<MaxFileSize>10MB</MaxFileSize>
</triggeringPolicy>
</appender>

<!-- 日志输出级别 -->
<root level="WARN">
<appender-ref ref="STDOUT" />
<appender-ref ref="FILE"/>
</root>
</configuration>

这些配置基本上都是最最基础的配置，具体的代表什么意思，网上也有很多很多的说明。
然后分别写了两个使用了common-logging和slf4j的接口：

package logService.service;

/**
 * 使用common-logger
 * 
 * @author tuzongxun
 * @date 2017年2月20日 下午3:36:19
 */
public interface CommonLogService {

    public void printLog(String msg);

}

package logService.service;

/***
 * Slf4j日志打印
 * 
 * @author tuzongxun
 * 
 * @date 2017年2月20日 下午3:39:11
 */
public interface Slf4jLogService {
    public void printLog(String msg);
}

还有对应的实现类，实现类实际上什么都没做，就是调用日志接口随便打印一条日志而已：

package logService.service.impl;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.stereotype.Component;

import logService.service.CommonLogService;

/**
 * 使用commons-logger和log4j打印日志
 * 
 * @author tuzongxun
 * @date 2017年2月20日 下午3:36:33
 */
@Component
public class CommonLogServiceImp implements CommonLogService {
    private Log logger = LogFactory.getLog(CommonLogServiceImp.class);

    public void printLog(String msg) {
        logger.warn("Commonlogger日志打印:" + msg);

    }
}

package logService.service.impl;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import logService.service.Slf4jLogService;

/***
 * Slf4j日志打印
 * 
 * @author tuzongxun
 * @date 2017年2月20日 下午3:38:55
 */
@Component
public class Slf4jLogServiceImpl implements Slf4jLogService {

    private Logger log = LoggerFactory.getLogger(Slf4jLogServiceImpl.class);

    @Override
    public void printLog(String msg) {
        log.warn("slf4j日志打印:" + msg);

    }
}

从上边的代码中，实际上根本看不出什么问题，只看到调用了两个接口而已，方法几乎都是一模一样，至于具体用了哪个实现，有什么区别呢，完全不知道，所以我写了对应的test类：

package logTest;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import logService.service.CommonLogService;
import logService.service.Slf4jLogService;

/**
 * 日志管理测试
 * 
 * @author tuzongxun
 * @date 2017年2月22日 下午3:40:17
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring.xml")
public class LogTest {
    @Autowired
    private CommonLogService commonLogService;

    @Autowired
    private Slf4jLogService slf4jLogService;

    @Test
    public void commonLogTest() {
        commonLogService.printLog("commonlog日志打印");
    }

    @Test
    public void slf4jLogTest() {
        slf4jLogService.printLog("slf4j日志打印");
    }

}

那么现在有了代码，我就可以说一说区别了，实际上一开始我说的pom.xml并不是一次导入的，可能有的项目中只有其中几个，而有的项目中我刚才导入的jar包他们也全都导入了。
经过我的测试发现，当使用common-logging的时候，是只能使用log4j的，如果去掉log4j的jar包，那么结果就是运行junit后没有生成对应的日志文件。
而如果用slf4j就可以使用两个实现，只不过和common-logging不同的是，使用slf4j时除开log4j的包，还需要slf4j连接log4j的包。
使用slf4j和logback要导入logback的包自然就不必说了，但是同时到如log4j和logback的包就导致了另一个问题存在，就是使用slf4j的时候不仅会用log4j，还会用logback，导致结果每次都会有两份日志文件。
因此呢，在这种情况下就需要导入另一个包，也就是我导入的

<dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>jcl-over-slf4j</artifactId>
        <version>1.7.12</version>
    </dependency>

有了这个包以后，便不会再有log4j的日志文件出现。
本例子已经上传到csdn下载：
http://download.csdn.net/user/tuzongxun