впервые в жизни я нахожусь в положении, когда я пишу Java API, который будет с открытым исходным кодом. Надеюсь быть включенным во многие другие проекты.

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

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

из исследования, которое я сделал, я придумал эти причины, почему люди не любят JUL:

1. "я начал разработку на Java задолго до того, как Sun выпустила JUL, и мне было просто легче продолжать работу с logging-framework-X, а не изучать что-то новое". Хм. Я не шучу, это на самом деле что говорят люди. С этим аргументом мы все могли бы делать COBOL. (однако я, конечно, могу относиться к этому быть ленивым чуваком сам)

2. "мне не нравятся названия уровней регистрации в июле". Хорошо, серьезно, это просто не достаточно оснований для введения новой зависимости.

3. "мне не нравится стандартный формат вывода из JUL". Хм. Это просто конфигурация. Вам даже не придется делать что-нибудь кодовое. (правда, в старые времена вам, возможно, пришлось создать свой собственный класс форматирования, чтобы получить его правильно).

4. "я использую другие библиотеки, которые также используют logging-framework-X, поэтому я подумал, что проще просто использовать этот". Это циклический аргумент, не так ли ? Почему "все" используют logging-framework-X, а не JUL?

5. "все остальные используют logging-framework-X". Это для меня просто особый случай из вышеперечисленного. Большинство не всегда правы.

так что настоящий большой вопрос почему не в июле?. Что же я упустил ? Смысл существования для лесозаготовительных фасадов (SLF4J, JCL) заключается в том, что исторически существовало несколько реализаций лесозаготовок, и причина этого действительно восходит к эпохе до июля, как я ее вижу. Если бы Джул была совершенна, то лесозаготовительные фасады не существовали бы, или что? Вместо того, чтобы обнимать их, разве мы не должны спрашивать, почему они были надо в первую очередь? (и посмотреть, если эти причины все еще существуют)

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

1. производительность. Некоторые говорят, что производительность в SLF4J превосходит остальные. Мне кажется, что это случай преждевременной оптимизации. Если вам нужно регистрировать сотни мегабайт в секунду, то я не уверен, что вы на правильном пути в любом случае. ИЮЛЬ также эволюционировал, и тесты, которые вы делали на Java 1.4, больше не могут быть истинными. Вы можете прочитать об этом здесь и это исправление превратило его в Java 7. Многие также говорят о накладных расходах на конкатенацию строк в методах ведения журнала. Однако ведение журнала на основе шаблона позволяет избежать этой стоимости, и она существует также В июле. Лично я никогда не пишу журнал на основе шаблонов. Слишком ленив для этого. Например, если я сделаю это с JUL:

   log.finest("Lookup request from username=" + username 
      + ", valueX=" + valueX
      + ", valueY=" + valueY));
   

   моя IDE предупредит меня и спросит разрешения, что это следует изменить его на:

   log.log(Level.FINEST, "Lookup request from username={0}, valueX={1}, valueY={2}", 
      new Object[]{username, valueX, valueY});
   

   .. что я, конечно, приму. Разрешение дано ! Спасибо за помощь.

   поэтому я на самом деле не пишу такие заявления сам, что делается IDE.

   в заключение по вопросу производительности я не нашел ничего, что могло бы предположить, что производительность Джула не в порядке по сравнению с конкуренцией.

2. конфигурация из classpath. Из-из-коробки июля не удается загрузить файл конфигурации из пути к классам. Это несколько строк кода чтобы сделать это так. Я понимаю, почему это может раздражать, но решение короткое и простое.

3. наличие обработчиков вывода. JUL поставляется с 5 обработчиками вывода из коробки: консоль, файловый поток, сокет и память. Они могут быть расширены или Новые могут быть написаны. Например, это может быть запись в системный журнал UNIX / Linux и журнал событий Windows. У меня есть лично у меня никогда не было этого требования, и я не видел его использования, но я, безусловно, могу понять, почему это может быть полезной функцией. Logback поставляется с приложением для системного журнала, например. Еще я бы поспорил, что

   1. 99,5% из потребностей для назначений выхода предусматривано чем в Джул вне -- коробке.
   2. специальные потребности могут обслуживаться обычными обработчиками поверх JUL, а не поверх чего-то еще. Мне ничего не говорит о том, что это займет больше времени для записи обработчика вывода системного журнала для JUL, чем для другой структуры ведения журнала.

Я действительно обеспокоен тем, что есть что-то, что я пропустил. Использование фасадов журналов и реализаций журналов, отличных от JUL, настолько широко распространено, что я должен прийти к выводу, что это я просто не понимаю. Боюсь, это будет не в первый раз. : -)

так что же мне делать с моим API? Я хочу, чтобы это стало успешный. Я могу, конечно, просто "пойти с потоком" и реализовать SLF4J (который кажется самым популярным в эти дни), но для меня самого мне все еще нужно понять, что именно не так с сегодняшним днем, который гарантирует весь пух? Буду ли я саботировать себя, выбирая Джул для своей библиотеки ?

тестирование производительности

(раздел добавлен nolan600 на 07-JUL-2012)

есть ссылка ниже от Ceki о параметризации SLF4J в 10 раз или быстрее, чем у Джула, поэтому я начал делать несколько простых тестов. На первый взгляд утверждение, безусловно, верно. Вот предварительные результаты (но читайте дальше!):

• время выполнения SLF4J, backend Logback: 1515
• время выполнения SLF4J, backend JUL: 12938
• время выполнения июль: 16911

цифры выше мсек, так что меньше лучше. Таким образом, разница в производительности в 10 раз на самом деле довольно близка. Мои инициалы реакция: это очень много !

вот ядро теста. Как видно, целое число и строка строятся в цикле, который затем используется в инструкции log:

    for (int i = 0; i < noOfExecutions; i++) {
        for (char x=32; x<88; x++) {
            String someString = Character.toString(x);
            // here we log 
        }
    }

(Я хотел, чтобы оператор log имел как примитивный тип данных (в данном случае int), так и более сложный тип данных (в данном случае строка). Не уверен, что это имеет значение, но там у вас есть.)

оператор log для SLF4J:

logger.info("Logging {} and {} ", i, someString);

заявление в журнале Джул:

logger.log(Level.INFO, "Logging {0} and {1}", new Object[]{i, someString});

JVM был "разогрет" с тем же тестом, выполненным один раз, прежде чем было сделано фактическое измерение. Java 1.7.03 был использован на Windows 7. Использовались последние версии SLF4J (v1.6.6) и Logback (v1.0.6). Stdout и stderr были перенаправлены на нулевое устройство.

однако, осторожно сейчас, оказывается, Джул проводит большую часть своего времени в getSourceClassName() за июль на печать по умолчанию имя исходного класса в выходной, а Logback так не. Так что мы сравниваем яблоки и апельсины. Я должен снова выполнить тест и настроить реализации ведения журнала аналогичным образом, чтобы они фактически выводили один и тот же материал. Однако я подозреваю, что SLF4J+Logback все равно выйдет на первое место, но далеко от начальных чисел, как указано выше. Оставайтесь с нами.

кстати: тест был первый раз, когда я на самом деле работал с SLF4J или Logback. Приятное переживание. Джул, конечно, гораздо менее приветливы, когда вы начинаете.

тестирование производительности (часть 2)

(раздел добавлен nolan600 на 08-JUL-2012)

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

java.util.logging.SimpleFormatter.format="%4$s: %5$s [%1$tc]%n"

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

поэтому я заключаю по вопросу производительности, что, по крайней мере, для тестируемого шаблона на основе оператора log, кажется, примерно в 10 раз больше реальной разницы в производительности между JUL (slow) и SLF4J+Logback (quick). Как и сказал чеки.

Я вижу еще одна вещь, а именно то, что SLF4J это getLogger() звонок намного дороже, чем Джул то же самое. (95 МС против 0,3 МС, если мой профилировщик точен). В этом есть смысл. SLF4J должен сделать некоторое время о привязке базовой реализации ведения журнала. Это меня не пугает. Эти вызовы должны быть несколько редкими в течение всего срока службы приложения. Быстрота должна быть в фактических вызовах журнала.

окончательный вывод

(раздел добавлен nolan600 на 08-JUL-2012)

Спасибо за все ваши ответы. Вопреки тому, что я изначально думал, я в конечном итоге решил использовать SLF4J для моего API. Это основано на ряде вещей и ваш вход:

1. это дает гибкость, чтобы выбрать реализацию журнала во время развертывания.

2. проблемы с отсутствием гибкости конфигурации JUL при запуске внутри сервера приложений.

3. SLF4J, безусловно, намного быстрее, как описано выше, в частности, если вы соедините его с Logback. Даже если это был просто грубый тест, у меня есть основания полагать, что гораздо больше усилий потрачено на оптимизацию SLF4J + Logback чем на июль.

4. документация. Документация для SLF4J просто намного более полная и точная.

5. гибкость модели. Когда я делал тесты, я решил, что JUL имитирует шаблон по умолчанию из Logback. Этот шаблон включает в себя имя потока. Оказывается, Джул не может сделать это из коробки. Хорошо, я не пропустил его до сих пор, но я не думаю, что это то, что должно отсутствовать в структуре журнала. И точка!

6. большинство (или многие) Java-проектов сегодня используют Maven, поэтому добавление зависимости не так уж и важно, особенно если эта зависимость довольно стабильна, т. е. не постоянно меняет свой API. Это похоже на правду для SLF4J. Также SLF4J банку и друзья имеют небольшой размер.

так что странная вещь, которая произошла, заключалась в том, что я на самом деле очень расстроился с JUL после того, как немного поработал с SLF4J. я все еще сожалею, что это должно быть вот так с ДЖУЛОМ. Джул далека от совершенства, но вроде делает свою работу. Просто недостаточно хорошо. То же самое можно сказать и о Properties в качестве примера, но мы не думаем об абстрагировании, чтобы люди могли подключить свою собственную библиотеку конфигурации и что у вас есть. Я думаю, причина в том, что Properties входит чуть выше бара, в то время как противоположное верно для июля сегодняшнего дня ... и в прошлом он приходил в ноль, потому что его не существовало.