Каждый класс, который хочет использовать java.util.logging, обычно должен объявлять регистратор следующим образом:
public class MyClass {
private static Logger _log = Logger.getLogger(MyClass.class.getName());
}
Как избежать этого шаблона MyClass.class.getName()?
У меня есть шаблон, установленный в Eclipse, так что мне нужно только набрать часть объявления, а затем Eclipse автоматически выполнит для меня остальное.
${:import(org.apache.log4j.Logger)}
private final static Logger log = Logger.getLogger(${enclosing_type}.class);
${cursor}
Итак, мне нужно только ввести logger, нажать Ctrl+Space, а затем Enter, а Eclipse заполнит остальное для меня и добавит также объявление импорта.
Это не сократит количество кода шаблона, но, по крайней мере, сократит количество нажатий клавиш.
Посмотрите на использование точечных сокращений в вашем коде
Я не оглядывался назад, используя их с помощью spring.
Вот статья об использовании AspectJ
В зависимости от ваших потребностей в регистрации вы можете создать класс "LoggingService" со статическими методами для входа в различные "каналы". Я обнаружил, что я действительно не нуждаюсь в детализации регистрации до уровня класса. Вы можете назвать своих регистраторов тем, что лучше всего подходит для вас. Мы используем это в крупных корпоративных приложениях в течение нескольких лет, и гранулярность действительно не была проблемой для нас.
Служба регистрации, инициализированная в статическом блоке инициализации... поэтому для регистрации сообщения:
LoggingService.logError( "бла" );
В каждом классе нет кода шаблона.
Вот пример службы ведения журнала:
public class LoggingService {
/**
* A log for informational messages.
*/
static private Logger infoLog;
/**
* A log for data access messages.
*/
static private Logger dataAccessLog;
/**
* A log for debug messages.
*/
static private Logger debugLog;
/**
* A log for error messages.
*/
static private Logger errorLog;
/**
* A log for all XML related messages.
*/
static private Logger xmlLog;
/**
* A log for all trace messages.
*/
static private Logger traceLog;
/**
* A log for all warning messages.
*/
static private Logger warnLog;
static {
//This is the bootstrap for the logging service.
//Setup each logger
infoLog = Logger.getLogger("com.company.logging.info");
dataAccessLog = Logger.getLogger("com.company.logging.dataaccess");
debugLog = Logger.getLogger("com.company.logging.debug");
errorLog = Logger.getLogger("com.company.logging.error");
xmlLog = Logger.getLogger("com.company.logging.xml");
traceLog = Logger.getLogger("com.company.logging.trace");
warnLog = Logger.getLogger("com.company.logging.warn");
// This must be set so isErrorEnabled() will work.
errorLog.setLevel(Level.ERROR);
warnLog.setLevel(Level.WARN);
}
static public void logDataAccess(String pMessage) {
dataAccessLog.info(pMessage);
}
static public void logInfo(String pMessage) {
infoLog.info(pMessage);
}
static public void logDebug(String pMessage) {
debugLog.debug(pMessage);
}
static public void logTrace(String pMessage) {
traceLog.debug(pMessage);
}
static public void logWarn(String pMessage) {
warnLog.warn(pMessage);
}
static public void logError(String pMessage) {
errorLog.error(pMessage);
}
static public void logError(String pMessage, Throwable pThrowable) {
errorLog.error(pMessage, pThrowable);
}
static public void logXml(String pMessage, XmlBean pContainer) {
if (!xmlLog.isInfoEnabled()) return;
xmlLog.info(pMessage + " : " + JAXBHelper.marshal(pContainer));
}
static public boolean isInfoEnabled() {
return infoLog.isInfoEnabled();
}
static public boolean isDataAccessEnabled() {
return dataAccessLog.isInfoEnabled();
}
static public boolean isDebugEnabled() {
return debugLog.isDebugEnabled();
}
static public boolean isErrorEnabled() {
if (errorLog.getLevel().toInt() >= Level.ERROR_INT) {
return true;
}
return false;
}
static public boolean isTraceEnabled() {
return traceLog.isDebugEnabled();
}
static public boolean isXmlEnabled() {
return xmlLog.isInfoEnabled();
}
static public boolean isWarnEnabled() {
return warnLog.isEnabledFor(Level.WARN);
}
}
На самом деле, обычная практика использования имен классов для имен журналов больше ленив.
Лучше использовать имена журналов в контексте задачи. Это включает в себя несколько более продуманный процесс и планирование, но, в конце концов, результатом является гораздо более заметная гранулярность, где вы можете переключать уровни ведения журнала для реальных задач, а не классов.
Вам не нужно getName(), если вы используете 1.24 версию log4j, getLogger() принимает аргумент Class. Но что касается остальных, нет никакого способа обойти это, если вы хотите, чтобы каждый класс имел статический член журнала со своей собственной категорией.
Если вы отправитесь на регистраторы уровня пакета, добавив класс шаблонов для каждого пакета, вы можете написать:
private static final Logger log = Logs.log;
Есть хаки, чтобы прочитать имя класса вызывающего (на самом деле реализация протокола имеет взломать для обнаружения текущего метода), но я бы не рекомендовал этого.
Вы можете уменьшить это и многие другие коды шаблонов с помощью ломбока
https://github.com/rzwitserloot/lombok
@Slf4j
public class LogExample {
}
будет
public class LogExample {
private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LogExample.class);
}
Вы можете сократить это немного, так как getLogger перегружен, чтобы просто взять класс. Например:
public class MyClass {
private static Logger _log = Logger.getLogger(MyClass.class);
}
Логгер может быть как беглым, так и негибким, как вы хотите. Вы можете захватить новый регистратор для каждого класса, как в приведенном выше примере, и иметь иерархию регистраторов, где вы можете управлять и включать/отключать ведение журнала по классам. Или, если ваш проект небольшой или прототип и т.д., Вы можете просто вызвать Logger.getRootLogger() - но вы потеряете гибкость тонкой настройки того, что вы регистрируете и не регистрируетесь. У вас может быть базовый класс, в котором хранится журнал, и каждый может его назвать, но опять-таки вы теряете некоторую гибкость:
public class MyBase {
protected static Logger _log = Logger.getLogger(MyClass.class);
}
public class MyClass extends MyBase {
....
_log.info("Stuff....");
}
В нижней строке, если вы хотите сохранить возможность тонкой настройки, настройте свою регистрацию позже в проекте (включите отладку более тонкого уровня только для одного класса), тогда вам, возможно, придется придерживаться шаблона в каждом классе.
Взгляните на SLF4J
Если вы сделаете журнал нестатически, вы можете по крайней мере наследовать его:
public class SomeBaseClass
{
protected Logger logger = Logger.getLogger(getClass());
}
public class SubClass extends SomeBaseClass
{
public void doit() { logger.debug("doit!!!!"); }
}
Как я всегда это делал.