Java_JDK_日志

快来打我* 2021-10-06 04:34 321阅读 0赞

### Java\_JDK\_日志 ###

*  简述
 *  实现
 *   *  项目统一调用接口Log
     *  核心实现-Log4j
     *  核心实现-JDK
     *  日志工具类

# 简述 #

个人jar封装，自定义日志接口

# 实现 #

## 项目统一调用接口Log ##

/**
     * The five logging levels used by Log are (in order):
     * 1. DEBUG (the least serious)
     * 2. INFO
     * 3. WARN
     * 4. ERROR
     * 5. FATAL (the most serious)
     */
    public abstract class Log {
    	
    	private static ILogFactory defaultLogFactory = null;
    	
    	static {
    		init();
    	}
    	 	
    	static void init() {
    		if (defaultLogFactory == null) {
    			try {
    			    //初始化优先查询log4j.jar   没有异常使用jdk
    				Class.forName("org.apache.log4j.Logger");
    				Class<?> log4jLogFactoryClass = Class.forName("com.xxx.log.Log4jLogFactory");
    				defaultLogFactory = (ILogFactory)log4jLogFactoryClass.newInstance();	// return new Log4jLogFactory();
    			} catch (Exception e) {
    				defaultLogFactory = new JdkLogFactory();
    			}
    		}
    	}
    	
    	static void setDefaultLogFactory(ILogFactory defaultLogFactory) {
    		if (defaultLogFactory == null) {
    			throw new IllegalArgumentException("defaultLogFactory can not be null.");
    		}
    		Log.defaultLogFactory = defaultLogFactory;
    	}
    	
    	public static Log getLog(Class<?> clazz) {
    		return defaultLogFactory.getLog(clazz);
    	}
    	
    	public static Log getLog(String name) {
    		return defaultLogFactory.getLog(name);
    	}
    	
    	public abstract void debug(String message);
    	
    	public abstract void debug(String message, Throwable t);
    	
    	public abstract void info(String message);
    	
    	public abstract void info(String message, Throwable t);
    	
    	public abstract void warn(String message);
    	
    	public abstract void warn(String message, Throwable t);
    	
    	public abstract void error(String message);
    	
    	public abstract void error(String message, Throwable t);
    	
    	public abstract void fatal(String message);
    	
    	public abstract void fatal(String message, Throwable t);
    	
    	public abstract boolean isDebugEnabled();
    
    	public abstract boolean isInfoEnabled();
    
    	public abstract boolean isWarnEnabled();
    
    	public abstract boolean isErrorEnabled();
    	
    	public abstract boolean isFatalEnabled();
    }

## 核心实现-Log4j ##

org.apache.log4j.Logger 需要引入log4j.jar

/**
     * Log4jLogFactory.
     */
    public class Log4jLogFactory implements ILogFactory {
    	
    	public Log getLog(Class<?> clazz) {
    		return new Log4jLog(clazz);
    	}
    	
    	public Log getLog(String name) {
    		return new Log4jLog(name);
    	}
    }
    
    /**
     * Log4jLog.
     */
    public class Log4jLog extends Log {
    	
    	private org.apache.log4j.Logger log;
    	private static final String callerFQCN = Log4jLog.class.getName();
    	
    	Log4jLog(Class<?> clazz) {
    		log = org.apache.log4j.Logger.getLogger(clazz);
    	}
    	
    	Log4jLog(String name) {
    		log = org.apache.log4j.Logger.getLogger(name);
    	}
    	
    	public static Log4jLog getLog(Class<?> clazz) {
    		return new Log4jLog(clazz);
    	}
    	
    	public static Log4jLog getLog(String name) {
    		return new Log4jLog(name);
    	}
    	
    	public void info(String message) {
    		log.log(callerFQCN, Level.INFO, message, null);
    	}
    	
    	public void info(String message, Throwable t) {
    		log.log(callerFQCN, Level.INFO, message, t);
    	}
    	
    	public void debug(String message) {
    		log.log(callerFQCN, Level.DEBUG, message, null);
    	}
    	
    	public void debug(String message, Throwable t) {
    		log.log(callerFQCN, Level.DEBUG, message, t);
    	}
    	
    	public void warn(String message) {
    		log.log(callerFQCN, Level.WARN, message, null);
    	}
    	
    	public void warn(String message, Throwable t) {
    		log.log(callerFQCN, Level.WARN, message, t);
    	}
    	
    	public void error(String message) {
    		log.log(callerFQCN, Level.ERROR, message, null);
    	}
    	
    	public void error(String message, Throwable t) {
    		log.log(callerFQCN, Level.ERROR, message, t);
    	}
    	
    	public void fatal(String message) {
    		log.log(callerFQCN, Level.FATAL, message, null);
    	}
    	
    	public void fatal(String message, Throwable t) {
    		log.log(callerFQCN, Level.FATAL, message, t);
    	}
    	
    	public boolean isDebugEnabled() {
    		return log.isDebugEnabled();
    	}
    	
    	public boolean isInfoEnabled() {
    		return log.isInfoEnabled();
    	}
    	
    	public boolean isWarnEnabled() {
    		return log.isEnabledFor(Level.WARN);
    	}
    	
    	public boolean isErrorEnabled() {
    		return log.isEnabledFor(Level.ERROR);
    	}
    	
    	public boolean isFatalEnabled() {
    		return log.isEnabledFor(Level.FATAL);
    	}
    }

## 核心实现-JDK ##

java.util.logging.Logger

/**
     * JdkLogFactory.
     */
    public class JdkLogFactory implements ILogFactory {
    	
    	public Log getLog(Class<?> clazz) {
    		return new JdkLog(clazz);
    	}
    	
    	public Log getLog(String name) {
    		return new JdkLog(name);
    	}
    }
    
    
    /**
     * JdkLog.
     */
    public class JdkLog extends Log {
    
    	private java.util.logging.Logger log;
    	private String clazzName;
    	
    	JdkLog(Class<?> clazz) {
    		log = java.util.logging.Logger.getLogger(clazz.getName());
    		clazzName = clazz.getName();
    	}
    	
    	JdkLog(String name) {
    		log = java.util.logging.Logger.getLogger(name);
    		clazzName = name;
    	}
    	
    	public static JdkLog getLog(Class<?> clazz) {
    		return new JdkLog(clazz);
    	}
    	
    	public static JdkLog getLog(String name) {
    		return new JdkLog(name);
    	}
    	
    	public void debug(String message) {
    		log.logp(Level.FINE, clazzName, Thread.currentThread().getStackTrace()[1].getMethodName(), message);
    	}
    	
    	public void debug(String message,  Throwable t) {
    		log.logp(Level.FINE, clazzName, Thread.currentThread().getStackTrace()[1].getMethodName(), message, t);
    	}
    	
    	public void info(String message) {
    		log.logp(Level.INFO, clazzName, Thread.currentThread().getStackTrace()[1].getMethodName(), message);
    	}
    	
    	public void info(String message, Throwable t) {
    		log.logp(Level.INFO, clazzName, Thread.currentThread().getStackTrace()[1].getMethodName(), message, t);
    	}
    	
    	public void warn(String message) {
    		log.logp(Level.WARNING, clazzName, Thread.currentThread().getStackTrace()[1].getMethodName(), message);
    	}
    	
    	public void warn(String message, Throwable t) {
    		log.logp(Level.WARNING, clazzName, Thread.currentThread().getStackTrace()[1].getMethodName(), message, t);
    	}
    	
    	public void error(String message) {
    		log.logp(Level.SEVERE, clazzName, Thread.currentThread().getStackTrace()[1].getMethodName(), message);
    	}
    	
    	public void error(String message, Throwable t) {
    		log.logp(Level.SEVERE, clazzName, Thread.currentThread().getStackTrace()[1].getMethodName(), message, t);
    	}
    	
    	/**
    	 * JdkLog fatal is the same as the error.
    	 */
    	public void fatal(String message) {
    		log.logp(Level.SEVERE, clazzName, Thread.currentThread().getStackTrace()[1].getMethodName(), message);
    	}
    	
    	/**
    	 * JdkLog fatal is the same as the error.
    	 */
    	public void fatal(String message, Throwable t) {
    		log.logp(Level.SEVERE, clazzName, Thread.currentThread().getStackTrace()[1].getMethodName(), message, t);
    	}
    	
    	public boolean isDebugEnabled() {
    		return log.isLoggable(Level.FINE);
    	}
    	
    	public boolean isInfoEnabled() {
    		return log.isLoggable(Level.INFO);
    	}
    	
    	public boolean isWarnEnabled() {
    		return log.isLoggable(Level.WARNING);
    	}
    	
    	public boolean isErrorEnabled() {
    		return log.isLoggable(Level.SEVERE);
    	}
    	
    	public boolean isFatalEnabled() {
    		return log.isLoggable(Level.SEVERE);
    	}
    }

## 日志工具类 ##

/**
     * LogKit.
     */
    public class LogKit {
    	
    	private static class Holder {
    		private static Log log = Log.getLog(LogKit.class);
    	}
    	
    	/**
    	 * 当通过 Constants.setLogFactory(...) 或者 
    	 * LogManager.me().setDefaultLogFacotyr(...)
    	 * 指定默认日志工厂以后，重置一下内部 Log 对象，以便使内部日志实现与系统保持一致
    	 */
    	public static void synchronizeLog() {
    		Holder.log = Log.getLog(LogKit.class);
    	}
    	
    	/**
    	 * Do nothing.
    	 */
    	public static void logNothing(Throwable t) {
    		
    	}
    	
    	public static void debug(String message) {
    		Holder.log.debug(message);
    	}
    	
    	public static void debug(String message, Throwable t) {
    		Holder.log.debug(message, t);
    	}
    	
    	public static void info(String message) {
    		Holder.log.info(message);
    	}
    	
    	public static void info(String message, Throwable t) {
    		Holder.log.info(message, t);
    	}
    	
    	public static void warn(String message) {
    		Holder.log.warn(message);
    	}
    	
    	public static void warn(String message, Throwable t) {
    		Holder.log.warn(message, t);
    	}
    	
    	public static void error(String message) {
    		Holder.log.error(message);
    	}
    	
    	public static void error(String message, Throwable t) {
    		Holder.log.error(message, t);
    	}
    	
    	public static void fatal(String message) {
    		Holder.log.fatal(message);
    	}
    	
    	public static void fatal(String message, Throwable t) {
    		Holder.log.fatal(message, t);
    	}
    	
    	public static boolean isDebugEnabled() {
    		return Holder.log.isDebugEnabled();
    	}
    	
    	public static boolean isInfoEnabled() {
    		return Holder.log.isInfoEnabled();
    	}
    	
    	public static boolean isWarnEnabled() {
    		return Holder.log.isWarnEnabled();
    	}
    	
    	public static boolean isErrorEnabled() {
    		return Holder.log.isErrorEnabled();
    	}
    	
    	public static boolean isFatalEnabled() {
    		return Holder.log.isFatalEnabled();
    	}
    }