Вы находите java.util.logging достаточный? [закрытый]

Question

Вы находите java.util.logging достаточный? [закрытый]

поздно к игре на этом ... у меня тоже есть еще одна перестановка ответа JarodPar.

вот Type.IsSubClassOf (Тип) любезно предоставлен отражателем:

    public virtual bool IsSubclassOf(Type c)
    {
        Type baseType = this;
        if (!(baseType == c))
        {
            while (baseType != null)
            {
                if (baseType == c)
                {
                    return true;
                }
                baseType = baseType.BaseType;
            }
            return false;
        }
        return false;
    }

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

    public static bool IsExtension(this Type thisType, Type potentialSuperType)
    {
        //
        // protect ya neck
        //
        if (thisType == null || potentialSuperType == null || thisType == potentialSuperType) return false;

        //
        // don't need to traverse inheritance for interface extension, so check/do these first
        //
        if (potentialSuperType.IsInterface)
        {
            foreach (var interfaceType in thisType.GetInterfaces())
            {
                var tempType = interfaceType.IsGenericType ? interfaceType.GetGenericTypeDefinition() : interfaceType;

                if (tempType == potentialSuperType)
                {
                    return true;
                }
            }
        }

        //
        // do the concrete type checks, iterating up the inheritance chain, as in orignal
        //
        while (thisType != null && thisType != typeof(object))
        {
            var cur = thisType.IsGenericType ? thisType.GetGenericTypeDefinition() : thisType;

            if (potentialSuperType == cur)
            {
                return true;
            }

            thisType = thisType.BaseType;
        }
        return false;
    }

в основном это просто метод расширения для System.Type - я сделал это, чтобы преднамеренно ограничить «thisType», Тип к конкретным типам, так как мое непосредственное использование - запрос LINQ «где» предикаты против объектов типа. я уверен, что все, что вы умные люди там могут повредить до эффективного, универсального статического метода, если вам нужно :) код делает несколько вещей, что код ответа не

откройте его до общего «расширения» - я рассматриваю наследование (мыслить классы), а также реализацию (интерфейсы); метод и имена параметров изменены, чтобы лучше отражать этот вход
ввода-валидации (meah)
ввода того же типа (класс не может распространяться)
short - выполнение схемы, если Тип в вопросе является интерфейсом; потому что GetInterfaces () возвращает все реализованные интерфейсы (даже те, что реализованы в суперклассах), вы можете просто пропустить эту коллекцию, не имея необходимости подниматься по дереву наследования

, остальное в основном такое же, как и Код JaredPar

41

logging java frameworks

задан Yuval Adam 4 March 2009 в 05:51

16 ответов

Лично я использую Простой Регистратор , но на работе я использую нашу корпоративную обертку для регистратора JDK. Я использую Простой Регистратор, из-за простоты получения, это настроило и то, что это поддерживает журналирование 7 уровней между Фатальным и Смехотворным.

0

ответ дан shrub34 4 August 2019 в 20:40

В проектах я продолжаю работать, мы склонны использовать вход свободного городского населения из Джакарты. Это не сама система регистрации, вместо этого она в состоянии обернуть некоторые наиболее распространенные регистраторы - log4j, java.util.logging или другие.

, С которым, относительно легко возможно переключить вход на основе среды, на которой развертывается приложение (разработчик может хотеть использовать simplelog или java.util.logging на его машине из-за простоты обслуживания, в то время как в НАХОДИТЬСЯ системе, log4j с общей конфигурацией для всех приложений может быть развернут, и т.д.)

1

ответ дан david a. 4 August 2019 в 20:40

Я был неспособен выяснить, как управлять регистрирующимся уровнем отдельных классов в java.util.logging платформе, что-то, что возможно в log4j. Если я испытываю затруднения при диагностировании ошибки или существует класс интенсивного трафика, который регистрирует важную информацию, я могу изменить уровень для единого класса, чтобы зарегистрироваться больше и оставить остальную часть моих классов относительно тихой.

N.B. Могло случиться так, что я не мог выяснить, как сделать это, или java.util.logging, возможно, изменился, так как я попробовал.

5

ответ дан Michael Sharek 4 August 2019 в 20:40

Довольно легко записать j.u.l LogManager класс, который задержит весь вход к сделанной на заказ реализации, которая использует Log4J. Это означает, что можно использовать log4j, но все еще иметь хорошую функцию, что библиотеками, которые регистрируют использование j.u.l, можно управлять, как будто они использовали Log4J.

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

log4j.error("An Exception", e);

jul.severe("An Exception", e); // GRRR! no such method

jul.log(Level.SEVERE, "An Exception", e); //Must use this method

, Почему они делали это проектное решение? Почему? Другая вещь состоит в том, что нет никакого PatternFormatter, который поставлется с j.u.l - Вы имеете к самокрутке.

Тем не менее я допускаю ошибку для использования j.u.l с этого времени, поскольку это сокращает внешние зависимости и не больше сложно для использования.

1

ответ дан oxbow_lakes 4 August 2019 в 20:40

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

logger.debug("The new entry is {}. It replaces {}.", entry, oldEntry);

, А не это:

logger.debug("The new entry is " + entry + ". It replaces " + oldEntry + ".");

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

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

16

ответ дан sblundy 4 August 2019 в 20:40

java.util.logging хорош, но не имеет конфигурации, которая поднята по умолчанию с пути к классу. Это - скорее болевая точка для нас, поскольку у нас есть много развертывания, который не совместно использует регистрирующиеся конфигурации, и это довольно грязно, чтобы сделать это в j.u.l.

Log4j в настоящее время не разрабатывается очень поэтому, если существует потребность в разработке на части бэкенда logback, в данный момент самая динамическая опция, по-моему.

(протест: вовлеченный в некоторую неясную разработку slf4j и logback, но это происходит из-за и не порождение операторов, которые я делаю выше:))

2

ответ дан Thorbjørn Ravn Andersen 4 August 2019 в 20:40

Одна из проблем, которые я имею со ВСЕМИ платформами журналирования, - то, что, если все в Вашей команде не проводят время для становления опытными в точно, как настроить ее и управлять ею, Вы никогда не знаете, распечатает ли данный оператор отладки или нет.

можно было выключить уровень (отладка), или можно было выключить один пакет.

я потратил впустую слишком много времени, предполагая, что оператор отладки распечатал бы, и он не делает. Теперь я главным образом полагаюсь на System.out.println () и просто прохожу и удаляю или преобразовываю их, когда я сделан, отладив.

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

Вход не состоит в том, что сложный и конечно выравнивается по ширине на большинстве больших проектов.

0

ответ дан Bill K 4 August 2019 в 20:40

Если нет неопровержимый довод для использования чего-то за пределами JDK, я предпочитаю использовать то, что обеспечивается Sun.

Многие проекты, которые используют вход Log4J, использовали его, прежде чем "стандартный" API входа существовал.

8

ответ дан TofuBeer 4 August 2019 в 20:40

Мы используем log4j с свободное городское население, регистрирующееся . Я думаю, что мы просто используем их, потому что все остальные делают. Это и мы использовали log4j, прежде чем jdk поддерживал вход.

Редактирование: справедливой, потому что все остальные делают, была шутка, но вероятно почему я начал с входом свободного городского населения и log4j.

Вот некоторые причины использовать вход свободного городского населения.

1

ответ дан ScArcher2 4 August 2019 в 20:40

Я думал, что буду использовать log4j - как упомянуто @ScArcher2, просто потому что все делают. Но после контакта с обеими опциями, я узнал, что java.util.logging достаточно далек достаточный для большинства моих потребностей - и я говорю об огромной системе со многим сотрудничеством компонентов распространения.

Так, по-моему, нет никакой потребности использовать альтернативные сервисы. Java.util.logging достаточно мощен для большинства случаев.

1

ответ дан Paulo Guedes 4 August 2019 в 20:40

java.util.logging (jul) was unnecessary from the beginning. Just ignore it.

jul in itself has the following downsides:

At the time that jul was introduced in Java 1.4 there was already a well established logging framework in wide use: LOG4J
the predefined log levels are: SEVERE, WARNING, INFO, CONFIG, FINE, FINER, FINEST. I won't tell you what I personally think about those predefined levels to keep this answer semi-objective.
Additional levels can be defined. jul supports up to 4G different log levels which is slightly overkill, IMHO. Less is sometimes more.
The most important point: if you dare to define your own log level you are likely to run into a memory leak issue!
Feel free to read about this effect here:
- Classloader leaks: the dreaded "java.lang.OutOfMemoryError: PermGen space" exception
- How to fix the dreaded "java.lang.OutOfMemoryError: PermGen space" exception (classloader leaks)
It's a pretty interesting read even if you are not planning to use custom levels, btw, since the problem is a wide-spread one that doesn't just apply to jul at all.
it resides in the java.* namespace so the implementation can't be exchanged at runtime. This effectively prevents bridging it to SLF4J the same way its possible in case of commons.logging and LOG4J. The way bridging is done for jul has a performance impact. This makes jul the most inflexible logging framework out there.
By introducing jul, Sun implicitly defined it to be the "standard java logging framework". This led to the common misconception that a "good Java citizen" should use jul in their libraries or applications.
The opposite is the case.
If you use either commons.logging or LOG4j you'll be able to exchange the actually used logging framework, if you ever need to, by bridging to SLF4J. This means that libraries using either commons.logging, LOG4J or SLF4J can all log to the same logging target, e.g. file.

I'd personally suggest to use the SLF4J+Logback combo for all logging purposes. Both projects are coordinated by Ceki Gülcü, the guy behind LOG4J.
SLF4J - достойный (но неофициальный, поскольку он не из той же группы) преемник commons.logging. Это менее проблематично, чем CL, поскольку оно статически разрешает фактически используемый серверный модуль журналирования. Кроме того, у него более богатый API, чем у CL.
Logback, с другой стороны, является (не) официальным преемником LOG4J. Он изначально реализует SLF4J, поэтому никаких накладных расходов, связанных с использованием какой-либо оболочки, не возникает.

Теперь вы можете проголосовать против меня, если все еще считаете, что я этого заслуживаю. ;)

46

ответ дан 27 November 2019 в 00:13

Средства ведения журнала JDK всегда делали то, что мне нужно, - никогда не было проблем с этим.

Для меня сторонние инструменты ведения журнала не нужны и нежелательны.

7

ответ дан 27 November 2019 в 00:13

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

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

-образующую проблему.
Проблемы с открытием или поиском нужного файла.

-4

ответ дан 27 November 2019 в 00:13

Мы везде используем java.util.logging. Также для крупных проектов. Есть несколько вещей, которые вам следует настроить (например, форматирование по умолчанию), но это не совсем так. Я считаю, что количество фреймворков ведения журналов в Java и внедренные ими функции довольно раздражают и несколько смущают Java-сообщество. . Уровень религиозных дебатов о лесозаготовках - верный признак того, что что-то пошло не так.

JUL дает вам простой, но достаточный API и единое место для настройки того, какой вывод журнала вы хотите видеть (logging.properties или JMX ...). И он всегда там и стабильно.

Весь код, который хочет вести журнал, должен придерживаться стандартных соглашений (уровень по умолчанию - INFO), а в противном случае делать ничего, кроме использования логгеров с осмысленным именем (например, имя пакета или класса), и все будет в порядке.

11

ответ дан 27 November 2019 в 00:13

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

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

Это могут быть простые текстовые файлы, которые перекатываются.
Это может быть сложнее, например, ведение журнала в JMS или базу данных.
Может потребоваться отдельный журнал для производительности, аудита и т.д.
Может потребоваться отправка подробностей по электронной почте, когда происходит событие в журнале.

Log4J в своем пакете varia имеет поддержку этих и других функций и протестирован с их API. Теперь с помощью java.util.logging вы сможете загрузить их, но они не так широко известны, как Log4J, и найти информацию для них может быть сложнее.

Еще одна вещь, которую следует учитывать, - это API поставщика, который вы используете. Большинство поставщиков "навязывают" вам API протоколирования. Spring - один из них, который требует commons-logging.

Как разработчик, я бы постарался использовать java.util.logging, если бы мог, для своих собственных вещей, но в реальных сценариях вы должны сообразить, что им понадобится в операциях и позволить этому управлять вашим выбором, потому что они - те, кому придется использовать эти журналы, когда приложение будет запущено. Ни архитектор приложения, ни разработчики не должны делать этот выбор, хотя они должны внести свои предложения.

1

ответ дан 27 November 2019 в 00:13

Другие вопросы по тегам:

logging java frameworks

Вход Зависимостей со Сторонними Библиотеками

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

Это находится в этих случаях, где потребность абстрагировать Ваш API входа от Вашей реализации входа становится важной. Я рекомендую использовать slf4j, или logback (использует slf4j API) как Ваш API и если Вы хотите продолжить работать с Java вход JDK, Вы все еще можете! Slf4j может произвести ко многим различным реализациям регистратора без проблем.

пример бетона А его полноценности произошел во время недавнего проекта: мы должны были использовать третье лицо, освобождает, которому был нужен log4j, но мы не хотели выполнять две платформы журналирования рядом, таким образом, мы использовали обертку slf4j log4j api, освобождает, и проблема была решена.

, Таким образом, Java вход JDK прекрасен, но стандартизированный API, который используется в моих сторонних библиотеках, сэкономит Вам время в конечном счете. Просто попытайтесь предположить осуществлять рефакторинг каждый оператор входа!

Вы находите java.util.logging достаточный? [закрытый]

16 ответов

Вход Зависимостей со Сторонними Библиотеками

Похожие вопросы: