Welche @NotNull-Java-Annotation sollte ich verwenden?

Question

Ich möchte meinen Code lesbarer machen und Tools wie IDE-Code-Inspektion und/oder statische Code-Analyse (FindBugs und Sonar) verwenden, um NullPointerExceptions zu vermeiden. Viele der Tools scheinen inkompatibel mit den anderen zu sein. @NotNull / @NonNull / @Nonnull Annotation und die Auflistung aller von ihnen in meinem Code wäre schrecklich zu lesen. Irgendwelche Vorschläge, welche die "beste" ist? Hier ist die Liste der gleichwertigen Annotationen, die ich gefunden habe:

• javax.validation.constraints.NotNull
  Erstellt für die Laufzeitvalidierung, nicht für die statische Analyse.
  Dokumentation

• edu.umd.cs.findbugs.annotations.NonNull
  Benutzt von FindBugs ( totes Projekt ) und dessen Nachfolger SpotBugs statische Analyse und damit Sonar (jetzt Sonarqube )
  FindBugs-Dokumentation , SpotBugs-Dokumentation

• javax.annotation.Nonnull
  Dies könnte auch mit FindBugs funktionieren, aber JSR-305 ist inaktiv. (Siehe auch: Wie ist der Status von JSR 305? ) Quelle

• org.jetbrains.annotations.NotNull
  Wird von IntelliJ IDEA IDE für die statische Analyse verwendet.
  Dokumentation

• lombok.NonNull
  Dient zur Steuerung der Codeerzeugung in Projekt Lombok .
  Platzhalter-Anmerkung, da es keine Norm gibt.
  Quelle , Dokumentation

• androidx.annotation.NonNull
  Marker-Anmerkung in Android verfügbar, bereitgestellt durch das Annotation-Paket
  Dokumentation

• org.eclipse.jdt.annotation.NonNull
  Wird von Eclipse für die statische Codeanalyse verwendet
  Dokumentation

Answer 1

Während Sie darauf warten, dass dieses Problem gelöst wird (Java 8?), können Sie auch einfach Ihr eigenes projektlokales @NotNull y @Nullable Anmerkungen. Dies kann auch nützlich sein, wenn Sie mit Java SE arbeiten, wo javax.validation.constraints ist nicht verfügbar standardmäßig.

import java.lang.annotation.*;

/**
 * Designates that a field, return value, argument, or variable is
 * guaranteed to be non-null.
 */
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.LOCAL_VARIABLE})
@Documented
@Retention(RetentionPolicy.CLASS)
public @interface NotNull {}

/**
 * Designates that a field, return value, argument, or variable may be null.
 */
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.LOCAL_VARIABLE})
@Documented
@Retention(RetentionPolicy.CLASS)
public @interface Nullable {}

Dies wäre zugegebenermaßen hauptsächlich zu dekorativen oder zukunftssichernden Zwecken, da die obigen Ausführungen offensichtlich an und für sich keine Unterstützung für die statische Analyse dieser Annotationen bieten.

Answer 2

Wenn Sie Ihre Anwendung mit Spring Framework erstellen, würde ich die Verwendung von javax.validation.constraints.NotNull kommend von Bohnen Validierung in folgender Abhängigkeit verpackt:

    <dependency>
        <groupId>javax.validation</groupId>
        <artifactId>validation-api</artifactId>
        <version>1.1.0.Final</version>
    </dependency>

Der Hauptvorteil dieser Annotation ist, dass Spring sowohl Methodenparameter als auch Klassenfelder unterstützt, die mit javax.validation.constraints.NotNull . Um die Unterstützung zu aktivieren, müssen Sie nur Folgendes tun:

1. liefern Sie das api jar für die Beans-Validierung und das jar mit der Implementierung des Validators der jsr-303/jsr-349-Annotationen (der mit der Abhängigkeit von Hibernate Validator 5.x geliefert wird):

   <dependency>
       <groupId>javax.validation</groupId>
       <artifactId>validation-api</artifactId>
       <version>1.1.0.Final</version>
   </dependency>
   <dependency>
       <groupId>org.hibernate</groupId>
       <artifactId>hibernate-validator</artifactId>
       <version>5.4.1.Final</version>
   </dependency>

2. MethodValidationPostProcessor für den Spring-Kontext bereitstellen

     @Configuration
     @ValidationConfig
     public class ValidationConfig implements MyService {
   
           @Bean
           public MethodValidationPostProcessor providePostProcessor() {
                 return new MethodValidationPostProcessor()
           }
     }

3. schließlich kommentieren Sie Ihre Klassen mit Spring's org.springframework.validation.annotation.Validated und die Validierung wird automatisch von Spring übernommen.

Ejemplo:

@Service
@Validated
public class MyServiceImpl implements MyService {

  @Override
  public Something doSomething(@NotNull String myParameter) {
        // No need to do something like assert myParameter != null  
  }
}

Wenn Sie versuchen, die Methode doSomething aufzurufen und null als Parameterwert übergeben, wird spring (mit Hilfe von HibernateValidator) ConstraintViolationException . Hier besteht kein Bedarf an manueller Arbeit.

Sie können auch Rückgabewerte validieren.

Ein weiterer wichtiger Vorteil von javax.validation.constraints.NotNull Das Besondere am Beans Validation Framework ist, dass es sich derzeit noch in der Entwicklung befindet und neue Funktionen für die neue Version 2.0 geplant sind.

Was ist mit @Nullable ? Es gibt nichts dergleichen in Beans Validation 1.1. Nun, ich könnte argumentieren, dass, wenn Sie entscheiden, zu verwenden @NotNull als alles, was NICHT mit dem Vermerk @NonNull ist effektiv "löschbar", so dass die @Nullable Vermerk ist nutzlos.

Answer 3

Einer der Vorzüge von IntelliJ ist, dass Sie die Annotationen nicht verwenden müssen. Sie können Ihre eigenen schreiben oder die eines anderen Tools verwenden. Sie sind nicht einmal auf einen einzigen Typ beschränkt. Wenn Sie zwei Bibliotheken verwenden, die unterschiedliche @NotNull Annotationen, können Sie IntelliJ anweisen, beide zu verwenden. Gehen Sie dazu zu "Configure Inspections", klicken Sie auf die Inspektion "Constant Conditions & Exceptions" und dann auf die Schaltfläche "Configure inspections" (Inspektionen konfigurieren). Ich verwende den Nullness Checker, wo immer ich kann, also habe ich IntelliJ so eingestellt, dass es diese Annotationen verwendet, aber Sie können es mit jedem anderen Tool, das Sie wollen, zum Laufen bringen. (Ich habe keine Meinung zu den anderen Tools, da ich die Inspektionen von IntelliJ seit Jahren benutze und sie liebe).

Answer 4

Wenn Sie für Android entwickeln, sind Sie etwas gebunden an Eclipse (edit: zum Zeitpunkt des Schreibens, nicht mehr), das seine eigenen Anmerkungen hat. Es ist in Eclipse 3.8+ (Juno) enthalten, aber standardmäßig deaktiviert.

Sie können diese Funktion unter Einstellungen > Java > Compiler > Fehler/Warnungen > Nullanalyse aktivieren (ausklappbarer Abschnitt am unteren Rand).

Aktivieren Sie "Annotationsbasierte Nullanalyse aktivieren".

http://wiki.eclipse.org/JDT_Core/Null_Analysis#Usage hat Empfehlungen zu den Einstellungen. Wenn Sie jedoch externe Projekte in Ihrem Arbeitsbereich haben (wie das Facebook-SDK), entsprechen diese möglicherweise nicht diesen Empfehlungen, und Sie möchten sie wahrscheinlich nicht bei jedem SDK-Update korrigieren ;-)

Ich benutze:

1. Zugriff auf Null-Zeiger: Fehler
2. Verstoß gegen die Null-Spezifikation: Fehler (verbunden mit Punkt 1)
3. Potenzieller Null-Zeiger-Zugriff: Warnung (sonst würde Facebook SDK Warnungen ausgeben)
4. Konflikt zwischen Null-Anmerkungen und Null-Inferenz: Warnung (verbunden mit Punkt #3)

Answer 5

Neuere Projekte sollten wahrscheinlich jakarta.annotation-api ( jakarta.annotation Paket).
Sie ist von nun an schreibgeschützt verlinkt javax.annotation repo und fügt sich in das neue Ökosystem von Jakarta ein, das darauf abzielt, die Gemeinschaft von allen javax verwandte Kopfschmerzen.