适配器模式在mybatis中的实践

MyBatis日志系统

Mybatis 可以集成多种第三方日志系统:如log4j,log4j2,commons-logging,slf4j等等，日志模块提供的接口各不相同，mybatis使用适配器模式，为每一个日志系统实现一个适配器。
需要适配的接口：

//mybatis 的4种日志级别已经够用了！
public interface Log {
    boolean isDebugEnabled();
    boolean isTraceEnabled();
    void error(String s, Throwable e);
    void error(String s);
    void debug(String s);
    void trace(String s);
    void warn(String s);
}

//适配器Log4jImpl，实现了Log接口，并封装了 org.apache.log4j.Logger对象，Log4jAdapter 的功能完全有logger实现
import org.apache.log4j.Level;
import org.apache.log4j.Logger;

public class Log4jAdapter implements Log {
private static final String FQCN     = Log4jImpl.class.getName();
    private final Logger log;
    public Log4jImpl(String clazz) {
        //适配器的关键实现，在构造器器中调用了Log4j
        //的静态方法，初始化了Logger log 字段
        this.log = Logger.getLogger(clazz);
    }
    public boolean isDebugEnabled() {
        return log.isDebugEnabled();
    }
    public boolean isTraceEnabled() {
        return log.isTraceEnabled();
    }
    public void error(String s, Throwable e) {
        log.log(FQCN, Level.ERROR, s, e);
    }
    public void error(String s) {
        log.log(FQCN, Level.ERROR, s, null);
    }
    public void debug(String s) {
        log.log(FQCN, Level.DEBUG, s, null);
    }
    public void trace(String s) {
        log.log(FQCN, Level.TRACE, s, null);
    }
    public void warn(String s) {
        log.log(FQCN, Level.WARN, s, null);
    }
}

//常用的方法 private static Log logger=LogFactory.getLog(类.class)
import org.apache.log4j.Logger;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class LogFactory {
    private static Constructor<? extends Log> logConstructor;
    //静态代码块初始化logConstructor
    static {
        tryImplementation(new Runnable() {
            public void run() {//注意是run()
                useLog4JLogging();
            }
        });
    }

    private static void tryImplementation(Runnable runnable) {
        if (logConstructor == null) {
            try {
                runnable.run();
            } catch (Throwable t) {
                // ignore
            }
        }
    }

    public static synchronized void useLog4JLogging() {
        setImplementation(Log4jImpl.class);
    }


    private static void setImplementation(Class<? extends Log> implClass) {
        try {
            Constructor<? extends Log> candidate = implClass.getConstructor(String.class);
            Log log = candidate.newInstance(LogFactory.class.getName());
            if (log.isDebugEnabled()) {
                log.debug("Logging initialized using '" + implClass + "' adapter.");
            }
            logConstructor = candidate;//
        } catch (Throwable t) {
            // throw new LogException("Error setting Log implementation.  Cause: " + t, t);
        }
    }
    private LogFactory() {
        // disable construction
    }
    //给外部调用
    public static Log getLog(Class<?> aClass) {
        return getLog(aClass.getName());
    }

    private static Log getLog(String logger) {
        try {
        //返回一个Log对象
            return logConstructor.newInstance(logger);
        } catch (Throwable t) {
            //throw new LogException("Error creating logger for logger " + logger + ".  Cause: " + t, t);
        }
        return null;
    }
}