незагроможденная регистрация с помощью scala?

Question

незагроможденная регистрация с помощью scala?

1

Мне нравится scala, так как это может помочь мне получить более чистый код.

Однако во время регистрации я чувствую, что мой код загромождает...

def myFunc(args) = {
  log.trace("entering myfunc, args are ... ")
  val result = doSomething()
  log.info("I really want to print that result which is {}", result)
  log.trace("exiting myfunc result {}", result)
  result
}

как вы можете видеть, а не просто звонить

def myFunc(args) = doSoemthing

Мне нужно было разбить результат на var чтобы я мог его сначала зарегистрировать и только потом вернуть. теперь это было простое использование в более сложных случаях использования. У меня больше логарифмов в моих методах, некоторые сведения info некоторых debug вещах становятся более сложными, а код становится намного более cluttered из-за регистрации.

в то время как я мог бы обернуть мой метод другим методом, который добавил бы регистрацию при входе и выходе, это сделает мой код более сложным, поэтому я ищу очень чистое решение для ведения журнала, не фокусируясь только на входе и выходе метода (я не хочу использовать AOP потому что он делает код более сложным и трудно понять).

как unclutter code, все еще имея код простой и понятный с мощным протоколированием? (решение еще не изобретено?) или есть истинное чистое решение?

Jas 25 март 2014, в 16:56

Источник

Теги:

java

scala

slf4j

logging

2 ответа

1

На этот вопрос уже был дан ответ и принят, но есть еще одно решение в ограниченном контексте отладки; и это, вероятно, может сочетаться с существующими решениями.

Полное раскрытие: я разработал Scart, поэтому я предвзято; независимо от того, элегантный ли это вопрос вкуса!

Если вы хотите выполнить трассировку, в отличие от ведения журнала, то есть испускать информацию об отладке для разработчиков и не хотите, чтобы в развернутом продукте вы могли попробовать трассировщики трассировки Scart.

Фактически, они пришли к существованию по той причине, о которой вы говорили; в какой-то степени они могут быть вставлены с правой стороны исходного кода, поэтому беспорядок не исчезает, но менее навязчив. По крайней мере, это работает для меня.

Я не пробовал следующее, но в вашем случае использования может выглядеть так:

def myFunc(args) = {                             
  val result = doSomething(args)
  log.info("I really ... which is {}", result)
  result                                             e_++: s"myFunc($args)"
}

Я оставил информацию о журнале, иначе:

def myFunc(args) = doSomething(args)                 e_++: s"myFunc($args)"

или скорее (Scart использует макросы, компилятор дает предупреждение, если эта трасса отключена):

def myFunc(args) =                                   s"myFunc($args)".e_++:
{
  doSomething(args)
}

Вы заметите, что я не писал длинные строки трассировки, но Scart автоматически добавляет такие данные, как класс, имена методов, строка # и т.д. Так как для отладки я лично обращаюсь к этим и не нужно писать очень длинные строки,

Есть больше вариантов, в конце концов я должен документировать их все.

Кроме того, Scart не требует работы регистратора. Чтобы выводить свои трассы в журналах, вам нужно назначить функцию printer которая использует регистратор (в настройках object Settings Scart), который имеет тип String => Unit.

Приветствия.

eruve 11 апр. 2014, в 17:58

Ещё вопросы

om-nom-nom · Accepted Answer · 2014-03-25T14-37-00.000Z

Прежде всего, ничто не мешает вам определить этот результат как val, а не var. Далее, есть такая вещь, как комбинатор пустельга (см. Также связанный ответ конкретно по теме журнала), который обычно используется для таких пустяков:

def myFunc(args) = {
  log.trace("entering myfunc, args are ... ")
  doSomething().tap { result => 
    log.info("I really want to print that result which is {}", result)
    log.trace("exiting myfunc result {}", result)
  }
}

Затем я верю, что похоже на методы AOP, такие как scala virtualized (которые позволяют вам суметь базовый синтаксис языка), но для меня это кажется огромным излишеством, я думаю, вы можете развернуть набор помощников и использовать их как:

traced(foo) { x => 
  myFunc(x) 
}

поэтому вход и выход будут регистрироваться

Я читал здесь javacodegeeks.com/2011/01/… на кончике 7, чтобы регистрировать каждый вход и выход метода, если это так, и мне нужно инкапсулировать каждый метод с помощью traced (foo). Я считаю, что никто на самом деле не следовал этому шаблону. что будет правильно?