В чем разница между scala StrictLogging и Lazylogging?

Рассмотрим приведенный ниже код, который использует scala logging:

class MyClass extends LazyLogging {
  logger.debug("This is very convenient")
}

В чем разница, если вместо этого использовать StrictLogging? Когда следует использовать какой?

Изменить. Я знаю, что такое лениво. Но я не могу получить его с точки зрения протоколирования и как он отличается от его функциональности по сравнению со строгим протоколированием. Это так, что я могу понять, когда использовать какой.

Ответы

Ответ 1

Я предполагаю, что вы ссылаетесь на typesafes scala -logging library. Разница заключается только в том, как logger определяется базовым регистратором, он может быть определен как нормальное значение или ленивое значение, что означает:

trait LazyLogging {
  @volatile protected lazy val logger: Logger =
      Logger(LoggerFactory.getLogger(getClass.getName))
}

против

trait StrictLogging {
  protected val logger: Logger =
    Logger(LoggerFactory.getLogger(getClass.getName))
}

Ответ 2

Что ж, похоже, все уже рассмотрели, что означает lazy, но на самом деле не упомянули, как это влияет на ваш выбор, поэтому я постараюсь перечислить правила, которым я следую сам.

По умолчанию используйте StrictLogging, особенно если класс одиночный или вы знаете, что методы журнала всегда будут вызываться.
Используйте LazyLogging, если вы создаете много объектов с этой чертой многократно. Однако, если вы делаете это, вы можете подумать о том, чтобы поместить этот регистратор в сопутствующий объект класса, чтобы не продолжать создавать экземпляр Logger и вызывать LoggerFactory.getLogger(...) снова и снова.

Может кто-нибудь придумать другие причины использовать/не использовать LazyLogging вместо StrictLogging?

Ответ 3

В чем разница между scala StrictLogging и Lazylogging?

Сначала прочитайте оба определения признаков:

trait LazyLogging {
 @volatile protected lazy val logger: Logger =
 Logger(LoggerFactory.getLogger(getClass.getName))
}

trait StrictLogging {
protected val logger: Logger =
 Logger(LoggerFactory.getLogger(getClass.getName))
}

Основное отличие - ключевые слова @volatile и lazy.

Как работает lazy?

Основная характеристика lazy val заключается в том, что связанное выражение не оценивается сразу, а один раз при первом доступе. Когда начальный доступ происходит, выражение оценивается. При последующем доступе дальнейшая оценка не выполняется, вместо этого сохраненный результат возвращается немедленно.

Для многопоточного сценария @volatile принудительно преобразует память в согласованное состояние по нескольким потокам.

Собственно, это зависит от индивидуального варианта использования, который имеет свойство использовать LazyLogging или StrictLogging.