org.slf4j.Logger#isErrorEnabled ( )源码实例Demo

@Override
public boolean shouldLog(int level, String category){
	Logger logger = getLogger(category);
	LogLevel logLevel = getLogLevel(level);
	
	switch (logLevel) {
	case TRACE:
		return logger.isTraceEnabled();
	case DEBUG:
		return logger.isDebugEnabled();
	case INFO:
		return logger.isInfoEnabled();
	case WARN:
		return logger.isWarnEnabled();
	case ERROR:
		return logger.isErrorEnabled();
	default:
		return true;
	}
}
 

@Override
public <T extends Exception> void errorAndThrow(String loggerName,
                                                Class<T> cls, String eInfo, String format, Object... values)
        throws RuntimeException {
    Logger logger = getLogger(loggerName);
    if (null == logger)
        return;
    if (logger.isErrorEnabled()) {
        String id = AlbianServiceRouter.getLogIdService().makeLoggerId();
        String msg = getErrorMsg(format, values);
        String tMsg = String.format("%s | %s.", id, msg);
        logger.error(tMsg);
        Class[] clss = new Class[]{String.class};
        Object[] vars = new Object[]{"Error:" + id + "," + eInfo};
        T throwObject = null;
        try {
            throwObject = (T) AlbianReflect.newInstance(cls, clss, vars);
        } catch (Exception e1) {
            throw new RuntimeException(e1);
        }
        if (null != throwObject)
            throw new RuntimeException(throwObject);
    }
}
 

public static int getLoggerLevel(Logger logger) {
    if (logger == null) {
        throw new NullPointerException("logger");
    }
    if (logger.isTraceEnabled()) {
        return TRACE_LEVEL;
    }
    if (logger.isDebugEnabled()) {
        return DEBUG_LEVEL;
    }
    if (logger.isInfoEnabled()) {
        return INFO_LEVEL;
    }
    if (logger.isWarnEnabled()) {
        return WARN_LEVEL;
    }
    if (logger.isErrorEnabled()) {
        return ERROR_LEVEL;
    }
    return DISABLE_LEVEL;
}
 

public static boolean isEnabledFor(Logger logger, LogLevel level) {
	switch (level) {
       case TRACE:
           return logger.isTraceEnabled();
       case DEBUG:
           return logger.isDebugEnabled();
       case INFO:
           return logger.isInfoEnabled();
       case WARN:
           return logger.isWarnEnabled();
       case ERROR:
           return logger.isErrorEnabled();
	}
	
	return false;
}
 

@Override
public <T extends Exception> void errorAndThrow(String loggerName,
                                                T e, String format, Object... values) throws RuntimeException {
    Logger logger = getLogger(loggerName);
    if (null == logger)
        return;
    if (logger.isErrorEnabled()) {
        logger.error(getErrorMsg(e, format, values));
        throw new RuntimeException(e);
    }

}
 

public static void error(Logger logger, String format, Supplier<Object>... supplier) {
    if (logger.isErrorEnabled()) {
        String[] o = new String[supplier.length];
        for (int i = 0; i < supplier.length; i++) {
            o[i] = Objects.toString(supplier[i].get());
        }
        logger.info(format, o);
    }
}
 

public static void reportIssueUnless(
    Logger logger, boolean predicate, Object subject, String format, Object... arguments
) {
    if (!predicate && logger.isErrorEnabled()) {
        doReportIssue(logger, subject, format, arguments);
    }
}
 

/**
 * check if log level is enabled in the underlying logger
 *
 * @param underlyingLogger real Slf4j Logger implementation
 * @param logLevel log level
 * @param marker marker
 * @return true if log level is enabled or false.
 */
public static boolean isLogLevelEnabled(Logger underlyingLogger, Level logLevel, Marker marker) {
    switch (logLevel) {
        case TRACE:
            if (marker == null) {
                return underlyingLogger.isTraceEnabled();
            }
            return underlyingLogger.isTraceEnabled(marker);
        case DEBUG:
            if (marker == null) {
                return underlyingLogger.isDebugEnabled();
            }
            return underlyingLogger.isDebugEnabled(marker);
        case INFO:
            if (marker == null) {
                return underlyingLogger.isInfoEnabled();
            }
            return underlyingLogger.isInfoEnabled(marker);
        case WARN:
            if (marker == null) {
                return underlyingLogger.isWarnEnabled();
            }
            return underlyingLogger.isWarnEnabled(marker);
        case ERROR:
            if (marker == null) {
                return underlyingLogger.isErrorEnabled();
            }
            return underlyingLogger.isErrorEnabled(marker);
        default:
            break;
    }
    return false;
}
 

public static Consumer<Object> ifErrorEnabled(
    Logger log, Supplier<String> message) {

    return o -> {
        if (log.isErrorEnabled()) {
            log.error(message.get(), o);
        }
    };
}
 

private void flush3(Logger logger, AlbianLoggerLevel level, String ctx) {
    switch (level) {
        case Debug:
            if (logger.isDebugEnabled()) {
                logger.debug(ctx);
                return;
            }
        case Info:
            if (logger.isInfoEnabled()) {
                logger.info(ctx);
                return;
            }
        case Warn:
            if (logger.isWarnEnabled()) {
                logger.warn(ctx);
                return;
            }
        case Error:
            if (logger.isErrorEnabled()) {
                logger.error(ctx);
                return;
            }
        case Mark:
            if (logger.isTraceEnabled()) {
                logger.trace(ctx);
                return;
            }
        default:
            if (logger.isInfoEnabled()) {
                logger.info(ctx);
                return;
            }
    }
    return;
}
 

@Override
protected boolean isEnabled(Logger logger) {
	return logger.isErrorEnabled();
}
 

public static void error(Logger logger, Supplier<Object> supplier) {
    if (logger.isErrorEnabled()) {
        logger.error(Objects.toString(supplier.get()));
    }
}
 

public static void reportIssue(Logger logger, Object subject, String format, Object... arguments) {
    if (logger.isErrorEnabled()) {
        doReportIssue(logger, subject, format, arguments);
    }
}
 

public static void error(Logger logger, String format, Supplier<Object> supplier) {
    if (logger.isErrorEnabled()) {
        logger.error(format, supplier.get());
    }
}
 

public static void error(Logger logger, Supplier<Object> supplier) {
    if (logger.isErrorEnabled()) {
        logger.error(Objects.toString(supplier.get()));
    }
}
 

@Override
public boolean isEnabled(final Logger logger)
{
    return logger.isErrorEnabled();
}
 

/**
 * Error.
 *
 * @param logger   the logger
 * @param format   the format
 * @param supplier the supplier
 */
public static void error(Logger logger, String format, Supplier<Object> supplier) {
    if (logger.isErrorEnabled()) {
        logger.error(format, supplier.get());
    }
}
 

/**
 * Error.
 *
 * @param logger   the logger
 * @param format   the format
 * @param supplier the supplier
 */
public static void error(Logger logger, String format, Supplier<Object> supplier) {
    if (logger.isErrorEnabled()) {
        logger.error(format, supplier.get());
    }
}
 

/**
 * Error.
 *
 * @param logger   the logger
 * @param supplier the supplier
 */
public static void error(Logger logger, Supplier<Object> supplier) {
    if (logger.isErrorEnabled()) {
        logger.error(Objects.toString(supplier.get()));
    }
}
 

/**
 * error level
 * @param logger
 * @param s
 * @param objs
 */
public static void error(Logger logger,String s,Object... objs){
    if(logger.isErrorEnabled()){
        logger.error(s,objs);
    }
}