Jetbrains runtime что это

Обновлено: 07.07.2024

Представляет собой Java-приложение с Apache Cassandra в роли локального хранилища данных и индексов.

Установка Upsource

Создаём каталог сервиса:

Загружаем архив со страницы загрузок, распаковываем:

Переносим в домашнюю директорию проекта:

Скрипты запуска располагаются в bin/ :

configures Upsource, call "help configure" for details starts Upsource in background, call "help start" for details

Сейчас запускаем с run :

command [hostname]: hostname: Name or service not known * JetBrains Upsource 2018.2 runtime environment is successfully configured command [hostname]: hostname: Name or service not known

Получаем сертификат через standalone аутентификатор, т.к. конфига NGINX ещё нет:

Saving debug log to /var/log/letsencrypt/letsencrypt.log How would you like to authenticate with the ACME CA? Select the appropriate number 1 then [enter] (press 'c' to cancel): 2 Plugins selected: Authenticator standalone, Installer None - Congratulations! Your certificate and chain have been saved at:

NGINX

Создаём файл настроек виртуалхоста, документация тут>>>:

Проверяем, перечитываем конфиги NGINX:

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok nginx: configuration file /etc/nginx/nginx.conf test is successful

Запуск Upsource

Меняем владельца каталога и файлов:

Переключаемся на пользователя upsource и запускаем используя start :

* JetBrains Upsource 2018.2 runtime environment is successfully configured

systemd unit

Останавливаем Upsource, который запускали вручную:

И запускаем уже через systemd :

Loaded: loaded (/etc/systemd/system/upsource.service; disabled; vendor preset: enabled) Active: active (running) since Tue 2019-04-02 10:23:43 UTC; 2s ago Apr 02 10:23:43 bttrm-testrail systemd[1]: Started Upsource Code Review service. Apr 02 10:23:44 bttrm-testrail bash[5356]: Starting Upsource.

Добавляем в автозапуск:

Created symlink /etc/systemd/system/multi-user.target.wants/upsource.service → /etc/systemd/system/upsource.service.

Настройка Upsource

Вводим токен из файла wizard_token.txt , жмём Log in, кликаем Set up:

Тут тоже всё можно оставить по умолчанию:

Ждём, пока он запустится:

Запускается 1-2 минуты:

PyCharm integration

В PyCharm переходим в Settings > Plugins, находим и устанавливаем Upsource Integration:

Я пытаюсь сделать мой код более читабельным, а также использовать такие инструменты, как проверка кода IDE и / или статический анализ кода (FindBugs и Sonar), чтобы избежать исключений NullPointerException. Многие инструменты кажутся несовместимыми с @NotNull / @NonNull / @Nonnull аннотациями друг друга, и перечисление их всех в моем коде было бы ужасно читать. Какие-нибудь предложения, какой из них является «лучшим»? Вот список эквивалентных аннотаций, которые я нашел:

javax.validation.constraints.NotNull
Создан для проверки во время выполнения, а не для статического анализа.
документация

edu.umd.cs.findbugs.annotations.NonNull
Используется FindBugs статического анализа и , следовательно , эхолота (теперь Sonarqube )
документации

javax.annotation.Nonnull
Это может работать и с Findbugs, но JSR-305 неактивен. (См. Также: Каков статус JSR 305? ) Источник

org.jetbrains.annotations.NotNull
Используется IntelliJ IDEA IDE для статического анализа.
документация

lombok.NonNull
Используется для управления генерацией кода в Project Lombok .
Заполнение аннотации, так как нет стандарта.
источник , документация

android.support.annotation.NonNull
Аннотация для маркеров, доступная в Android, предоставляется документацией пакета support-annotations

org.eclipse.jdt.annotation.NonNull
Используется Eclipse , для анализа статического кода
документации

Apache должен изобрести «общую» аннотацию и инструмент, который может преобразовать ее в любую другую аннотацию. Решение проблемы слишком большого числа стандартов состоит в том, чтобы изобрести новый стандарт. @irreputable если apache изобрел новый «общий», его будет 56 версий, совпадающих с другими проектами. И, в любом случае, это не будет стандартом (стандартным! = Широко распространенным). Лучше использовать что-нибудь действительно стандартное, javax?. *. Кстати, в этих примерах не слишком много стандартов, я просто вижу 1 или 2. javax.annotation.Nonnull работает с findbugs (только что проверил), что является убедительной причиной для его использования. Если я просто напишу @NotNull, это относится к com.sun.istack.internal.NotNull . OMG . @MozartBrocchini - дополнительные функции полезны в тех случаях, когда вы могли ранее использовать NullObjects. Они на самом деле не имеют той же цели, что и аннотация runtime \ @NotNull, и вводят утомительную распаковку.

Начиная с JSR 305 (целью которого было стандартизировать @NonNull и @Nullable ) была неактивной в течение нескольких лет, я боюсь, что нет хорошего ответа. Все, что мы можем сделать, это найти прагматическое решение, и мое следующее:

Синтаксис

С чисто стилистической точки зрения я хотел бы избегать любых ссылок на IDE, фреймворк или любой инструментарий, кроме самой Java.

Что оставляет нас с javax.validation.constraints или javax.annotation . Бывший поставляется с JEE. Если это лучше, чем javax.annotation , что может в конечном итоге прийти с JSE или вообще никогда, это вопрос дискуссии. Я лично предпочитаю javax.annotation потому что я не хотел бы зависимость JEE.

Это оставляет нас с

javax.annotation

который также самый короткий.

Существует только один синтаксис, который был бы даже лучше: java.annotation.Nullable . Как закончили другие пакеты от javax до java в прошлом, javax.annotation было бы шагом в правильном направлении.

Реализация

Я надеялся, что у них у всех одинаковая тривиальная реализация, но подробный анализ показал, что это не так.

Сначала за сходство:

Все @NonNull аннотации имеют строку

org.jetbrains.annotations который называет это @NotNull и имеет тривиальную реализацию
javax.annotation который имеет более длительную реализацию
javax.validation.constraints который также называет это @NotNull и имеет реализацию

Все @Nullable аннотации имеют строку

кроме (опять же) org.jetbrains.annotations с их тривиальной реализацией.

Поразительным является то, что

у всех есть аннотации времени выполнения ( @Retention(RUNTIME) ), в то время как

android.support.annotation
edu.umd.cs.findbugs.annotations
org.eclipse.jdt.annotation
org.jetbrains.annotations

только время компиляции ( @Retention(CLASS) ).

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

Другое важное отличие состоит в том, где в коде могут использоваться аннотации. Есть два разных подхода. Некоторые пакеты используют контексты стиля JLS 9.6.4.1. Следующая таблица дает обзор:

Это оставляет нас с

Чтобы помочь вам сравнить дальнейшие детали, я перечислю код каждой аннотации ниже. Чтобы упростить сравнение, я удалил комментарии, импорт и @Documented аннотацию. (все они были @Documented за исключением классов из пакета Android). Я изменил порядок строк и @Target полей и нормализовал квалификации.

Для полноты, вот @Nullable реализации:

Следующие два пакета не имеют @Nullable , поэтому я перечислю их отдельно; Ломбок довольно скучный @NonNull . В на самом деле и имеет длинноватые реализацию. javax.validation.constraints @NonNull @NotNull

Служба поддержки

Из моего опыта, javax.annotation по крайней мере, поддерживается Eclipse и Checker Framework из коробки.

Резюме

Моей идеальной аннотацией был бы java.annotation синтаксис с реализацией Checker Framework.

Если вы не собираетесь использовать Checker Framework, то javax.annotation ( JSR-305 ) пока что остается лучшим выбором.

источники

Еще одно замечание javax.annotation - это вызывает проблемы с Java 9, потому что другие модули также предоставляют классы в этом пакете (jax-ws). JSR 305 , который был бы стандартизирован javax.annotation.NonNull , так и не был завершен, потому что его спецификационный лидер вышел из AWOL Это не имело никакого отношения к решению Oracle.

Мне очень нравится Checker Framework , представляющий собой реализацию аннотаций типов ( JSR-308 ), которая используется для реализации средств проверки дефектов, таких как средство проверки на нулевое значение. На самом деле я не пробовал других предлагать какое-либо сравнение, но я доволен этой реализацией.

Я не связан с группой, которая предлагает программное обеспечение, но я фанат.

Четыре вещи, которые мне нравятся в этой системе:

У него есть дефекты для проверки на нулевое значение (@Nullable), но также есть и для неизменяемости и интернирования (и других). Я использую первое (нулевое значение) и пытаюсь использовать второе (неизменность / IGJ). Я пробую третий, но пока не уверен, что буду использовать его в долгосрочной перспективе. Я еще не убежден в общей полезности других средств проверки, но приятно знать, что сама структура представляет собой систему для реализации множества дополнительных аннотаций и средств проверки.

Настройка по умолчанию для проверки на нулевое значение работает хорошо: ненулевое значение, кроме локальных (NNEL). В основном это означает, что по умолчанию средство проверки обрабатывает все (переменные экземпляра, параметры метода, универсальные типы и т. Д.), За исключением локальных переменных, как если бы они имели тип @NonNull по умолчанию. Согласно документации:

Значение NNEL по умолчанию приводит к наименьшему количеству явных аннотаций в вашем коде.

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

Этот каркас позволяет вам использовать его без создания зависимости от каркаса , заключив свои комментарии в комментарий: например /*@Nullable*/ . Это хорошо, потому что вы можете аннотировать и проверять библиотеку или общий код, но при этом иметь возможность использовать эту библиотеку / общий код, закодированный в другом проекте, который не использует платформу. Это хорошая особенность. Я привык к его использованию, хотя сейчас я имею тенденцию включать Checker Framework во всех моих проектах.

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

Кажется великолепным, и я хотел бы использовать это, но не могу. Почему GPL? Не может ли это быть LGPL вместо этого? В соответствии с часто задаваемыми вопросами : «Более разрешающая лицензия MIT применяется к коду, который вы, возможно, захотите включить в свою собственную программу, например к аннотациям». Ссылки в настоящее время не работают. Но +1 за совет по использованию Checker Framework. Жаль, что в последнем выпуске пропущены контролеры неизменности.

Я использую тот IntelliJ, потому что меня больше всего интересует то, что IntelliJ помечает вещи, которые могут создавать NPE. Я согласен, что расстраивает отсутствие стандартной аннотации в JDK. Говорят о его добавлении, он может превратиться в Java 7. В таком случае будет еще один на выбор!

javax.annotation.Nonnull более широко принят, не так ли? @DanielAlexiuc Но, к сожалению, он не использует их для своих проверок во время выполнения, поэтому все еще есть преимущество в использовании JetBrains . @Trejkaz С 2016.3 он создает проверки во время выполнения для всех этих.

Согласно списку возможностей Java 7 аннотации типа JSR-308 откладываются до Java 8. Аннотации JSR-305 даже не упоминаются.

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

Фактически, JSR-308 не определяет какие-либо типы / классы аннотаций, и похоже, что они думают, что это выходит за рамки. (И они правы, учитывая существование JSR-305).

Однако, если JSR-308 действительно выглядит как превращение в Java 8, меня не удивит, если интерес к JSR-305 возродится. AFAIK, команда JSR-305 официально не отказалась от своей работы. Они просто молчали 2+ года.

Интересно, что Билл Пью (технический лидер JSR-305) - один из тех, кто стоит за FindBugs.

Для проектов Android вы должны использовать android.support.annotation.NonNull и android.support.annotation.Nullable . Эти и другие полезные аннотации для Android доступны в библиотеке поддержки .

Сама библиотека поддержки также была аннотирована этими аннотациями, так что, как пользователь библиотеки поддержки, Android Studio уже проверит ваш код и отметит потенциальные проблемы на основе этих аннотаций.

Было бы полезно представить обоснование этой рекомендации. tools.android.com/tech-docs/support-annotations "Сама библиотека поддержки также помечена этими аннотациями, поэтому, как пользователь библиотеки поддержки, Android Studio уже проверит ваш код и отметит потенциальные проблемы на основе этих аннотаций. «. Кстати, Android Studio поддерживает также jsr305 с javax.annotation.* аннотациями

Если кто-то просто ищет классы IntelliJ: вы можете получить их из репозитория maven с помощью

Это тот, который заставляет Intellij выдавать предупреждения, да. Твое право. Я обновил версию. Даже если я предполагаю, что это не сильно изменилось. Помните, что аннотации JetBrains не сохраняются для среды выполнения, поэтому, например, поддержка Guice @Nullable не работает с ней.

JSR305 и FindBugs созданы одним и тем же человеком. Оба плохо обслуживаются, но являются стандартными и поддерживаются всеми основными IDE. Хорошей новостью является то, что они работают хорошо, как есть.

2. Добавьте аннотацию к каждому пакету: package-info.java

ОБНОВЛЕНИЕ : По состоянию на 12 декабря 2012 года JSR 305 числится как «неактивный». Согласно документации:

JSR, который был признан Исполнительным комитетом «спящим», или тот, который достиг конца своей естественной жизни.

Исправлена проблема с showtopper для maven. Так что это должен быть вариант снова. Я использую FindBugs через Maven, моя IDE ничего не делает, это позволяет избежать конкретных аннотаций IDE, что бы вы порекомендовали? @ChristopheRoussy Ваш вопрос относится к среде IDE. Пожалуйста, откройте отдельный вопрос.

Различают статический анализ и анализ времени выполнения. Используйте статический анализ для внутренних вещей и анализ времени выполнения для открытых границ вашего кода.

Для вещей, которые не должны быть нулевыми:

Используйте Необязательный для типов возвращаемых методов (только). Либо Java8, либо гуава.

Статическая проверка: используйте аннотацию @NonNull

Иначе, используйте @ . CheckForNull при возврате метода, чтобы избежать NPE

Это должно дать наилучший результат: предупреждения в среде IDE, ошибки от Findbugs и checkerframework, значимые исключения во время выполнения.

Не ожидайте, что статические проверки станут зрелыми, их имена не стандартизированы, а разные библиотеки и IDE обрабатывают их по-разному, игнорируют их. Классы JSR305 javax.annotations. * Выглядят как стандартные, но это не так, и они вызывают разделение пакетов с Java9 +.

Некоторые примечания к объяснениям:

До Java9 это моя рекомендация:

Обратите внимание, что нет способа заставить Spotbugs выдавать предупреждение при разыменовании параметра метода, допускающего значение NULL (на момент написания, версия 3.1 Spotbugs). Может быть, проверочная схема может сделать это.

К сожалению, эти аннотации не делают различий между случаями открытого метода библиотеки с произвольными местами вызова и непубличными методами, в которых может быть известен каждый из них. Таким образом, двойное значение: «Укажите, что null нежелателен, но, тем не менее, подготовьтесь к тому, что null будет передан», невозможно в одном объявлении, поэтому в приведенном выше примере есть разные аннотации для интерфейса и реализации.

Для случаев, когда подход с разделенным интерфейсом не практичен, следующий подход является компромиссом:

Это помогает клиентам не передавать ноль (писать правильный код), возвращая при этом полезные ошибки, если они это делают.

Хорошему специалисту нужен хороший инструмент. Это правило касается и разработчиков ПО. Программисты могут бесконечно спорить о преимуществах разных IDE, но вряд ли кто-то скажет, что предпочитает писать весь код в текстовом редакторе.

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

Некоторые компании выдают лицензионное ПО бесплатно — такая возможность доступна студентам и иногда преподавателям. Самые популярные инструменты мы собрали в этой статье. О бесплатных альтернативах дорогостоящего ПО, таких как Octave, мы здесь рассказывать не будем — это тема для отдельного материала.

Примечание Когда мы говорим «‎студенты», подразумеваем также и школьников: как правило, нужно быть не младше 13 лет и учиться в лицензированном учебном учреждении. Для оформления большинства подписок потребуется ваш студенческий/преподавательский адрес электронной почты, удостоверение ISIC или ITIC. Чтобы не повторяться в каждом пункте, мы расскажем об этих популярных способах верификации в конце подборки.

JetBrains

Что предоставляют?

IntelliJ IDEA — одна из самых популярных разработок компании, IDE для JVM. Community версия этой среды разработки доступна и бесплатно. В версии Ultimate компания предлагает такие дополнения:

интеграцию системы управления версиями Perforce;
поддержку JavaScript и TypeScript;
поддержку распространённых фреймворков и технологий, таких как Hibernate, Guice, FreeMarker, Velocity, Thymeleaf, Java EE, Spring, GWT, Vaadin, Play и других;
инструменты для работы с базами данных и SQL;
обнаружение повторяющихся участков кода.

Кроме этих двух больших продуктов, JetBrains предлагает студентам и преподавателям такие IDE:

Как получить?

Способ 1. Студенческий/преподавательский адрес электронной почты. Помимо него потребуется сообщить статус (студент/преподаватель), имя и фамилию и страну, в которой находится учебное заведение. У студентов спросят про возраст, для оформления подписки нужно достичь 13 лет. На преподавателей это требование, видимо, не распространяется.

Способ 2. Обладатели удостоверения ISIC/ITIC могут ввести данные своей карточки — серийный номер и отображённое на карте имя. В таком случае ученический адрес личной электронной почты не требуется, подойдёт любой.

Способ 3. Можно попробовать предоставить официальный документ, подтверждающий ваш статус — например, студенческий билет. Нужно будет ввести имя и фамилию, адрес электронной почты (любой, принадлежащий вам), название учебного заведения, его официальный веб-сайт и страну размещения. Также надо подтвердить, что учебное заведение предоставляет услуги среднего или высшего образования и выдаёт дипломы государственного образца, а вы участвуете в образовательной программе длительностью от одного года. Скан или фотография документа должны быть не больше 4 мегабайт, содержать ваше имя, название образовательного учреждения, указания на срок действия документа. Надписи должны быть хорошо читаемы и доступны для перевода с помощью Google Translate. Вместо изображения документа можно предоставить ссылку на информацию.

Способ 4. Если вы оформили подписку на GitHub Student Developer Pack, можно подтвердить свой статус с помощью аккаунта GitHub. Вас автоматически переведут с сайта JetBrains на форму авторизации.

Срок подписки?

Лицензия предоставляется на один год и её можно продлевать — вам пришлют напоминание по электронной почте. Выпускники получают скидку 25% на покупку ПО, входящего в пакет. Скидка действительна в течение года после выпуска.

GitHub

В разделе выше мы упомянули GitHub Student Developer Pack, поговорим о нём подробнее. Студенты могут бесплатно получить почти две дюжины инструментов.

Как работает org.jetbrains.annotations.Contract Работа с аннотациями? Как IntelliJ IDEA поддерживает это?

Прежде всего, я должен сказать, что эта аннотация предназначена только для IDEA для проверки возможных ошибок. Компилятор Java будет игнорировать его почти полностью (он ' Я буду в скомпилированном артефакте, но не окажу никакого эффекта). Сказав это .

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

Возможные входные данные: _ (любое значение), null , !null (не нулевое), false и true и возможные выходные данные добавляют fail в этот список.

Так, например, null -> false означает, что при условии ввода null логическое значение false является результатом. null -> false; !null -> true расширяется, чтобы сказать, что null будет всегда вернет false , а не - null значение будет всегда верните true и т. д. Наконец, null -> fail означает, что метод сгенерирует исключение, если вы передадите ему нулевое значение.

Для примера с несколькими аргументами null, !null -> fail означает, что в методе с двумя аргументами, если первый аргумент равен нулю, а второй не равен нулю, исключение будет выдано, гарантировано.

Если метод не изменяет состояние объекта, а просто возвращает новое значение, вам следует установить для pure значение true.

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

С точки зрения непрофессионала:

Контракт может иметь 1 или более пунктов, связанных с ним
Предложение всегда [args] -> [effect]
Аргументы - это 1 или более ограничений, которые определены как any | null | !null | false | true
Эффекты - только одно ограничение или fail

Давайте рассмотрим краткий пример - один из моих любимых: "Что бы вы ни указали в этом методе, оно выдаст исключение".

Здесь мы используем _ или "любой", чтобы указать, что независимо от того, что мы передаем в этот метод, мы собираемся вызвать исключение.

Что если мы солгали и сказали, что этот метод безоговорочно вернет true ?

IntelliJ выдвигает некоторые предупреждения об этом.

Также (очевидно) расстроено, что мы сказали, что возвращаем логическое значение, когда находимся в void методе. ..

Основные моменты, когда вы захотите использовать @Contract это когда:

Вы хотите гарантировать, что вы вернете true или false
Вы хотите гарантировать, что вы возвращаете ненулевое значение с учетом ограничений
Вы хотите прояснить, что вы можете вернуть нулевое значение с учетом ограничений
Вы хотите прояснить, что вы бросите исключение с учетом ограничений

Это не значит, что @Contract идеально; отнюдь не. Он не может выполнять очень глубокий анализ в определенных контекстах, но наличие этого в вашей кодовой базе позволяет вашим инструментам проводить такой анализ бесплатно.

Как работает аннотация _ org.jetbrains.annotations.Contract _?

Хотя предыдущие ответы носят информативный характер, я не чувствую, что они касаются оперативного слова "работа" в вашем вопросе. То есть они не объясняют, что IntelliJ делает за кулисами для реализации своих аннотаций, чтобы вы могли легко создавать свои собственные с нуля.

Если вы посмотрите на исходный код ниже, вы можете подумать, что он кажется слишком сложным (или, по крайней мере, многословным) для чего-то столь же простого звучания, как _ @NotNull _. Я согласен с вами, и это одна из причин, по которой я обычно избегаю _ @Contract _-подобных предложений, которые не являются "простыми и понятными" (например, _ @NotNull _), а вместо этого JavaDoc напрямую выполняет мои предварительные требования.

I как правило не поощряйте использование сложных аннотаций контракта - несмотря на ненависть, которую я могу получить за пропуск этого модного нового поезда - и вот несколько причин, почему:

Аннотации могут быть сложными - например, наличие нескольких вложенных аннотаций в их собственных определениях и/или "грамматике" с появлением полноты Тьюринга . Это может привести к ложному чувству уверенности во время компиляции, маскируя истинного виновника ошибки за слоями неясности/абстракции и не генерируя изначально намеченные предупреждения.
Аналогично, но отличается от моего предыдущего пункта, аннотации часто скрывают обильную логику от разработчика в нескольких ключевых словах, создавая трудный для понимания код для людей и/или необычное поведение, которое может быть трудно отладить.
Конфигурация приложения часто рассматривается как маскировка как аннотации. Посмотрите на Spring Framework .
Синтаксис определения контрактов по большому счету (IMHO) довольно уродливый и Makefile-ish. Например, взгляните на некоторые определения аннотаций JetBrains и вспомогательные файлы разбросаны по репо . Заметили многочисленные XML-файлы и многообещающие ссылки? Я вряд ли назвал бы это забавным для написания и поддержки, особенно учитывая постоянно меняющуюся природу аннотаций, возглавляемых спорами между Android и большим Java сообществом.

Некоторые вопросы для рассмотрения:

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

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

Когда и какие контракты следует использовать?

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

Примером использования - несмотря на предыдущий сегмент - является _ @NotNull _, но ограничивайте его тем, что все параметры объекта должны быть нулевыми.

Примером такого вида, которого следует избегать, являются такие, как Android и @Contract(. ) IntelliJ. Хотя я действительно люблю их IDE, детали их аннотаций довольно сложны и, в конечном итоге, превратились в источник новых проблем и несовместимости платформ, которые я могу отследить (по общему признанию, из-за моего собственного невежества в создании новых контрактов почти в 100% случаев, но почему так сложно все сделать правильно?)

Резюме/Заключение

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

Дальнейшее чтение

Этот краткий список представляет собой смесь наиболее важных (с оптимизмом!) Источников как из StackOverflow, так и из Интернета, которые, как мне кажется, иллюстрируют некоторые из моих соображений.

В произвольном порядке:

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

Читайте также: