Travailler comme une équipe! Face Null de front en Java

Je m'excuse d'avoir inventé la référence Null lors de la conférence 2009.

C'est mon erreur qui vaut un milliard de dollars.

Null C'est un problème haineux qui tourmente toujours les développeurs utilisant des langages non sécurisés. Informaticien [Antony Hoa | wikipedia](https://ja.wikipedia.org/wiki/%E3%82%A2%E3%83%B3%E3%83%88%E3%83%8B% Comme E3% 83% BC% E3% 83% BB% E3% 83% 9B% E3% 83% BC% E3% 82% A2) dit plus haut, c'est une dette technique tissée dans la langue. Ce n'est pas exagéré à dire.

Dans le nouveau développement moderne, les langues non sécurisées nulles ne sont plus des langues héritées | Qiita L'idée d'éviter les langues non sécurisées nulles elles-mêmes, comme dans l'article Il y aura. Cependant, il y a encore des situations où vous devez choisir une langue qui n'est pas sûre pour diverses raisons.

Donc, cette fois, je vais réfléchir à la méthode pour faire face à Null en Java.

Précautions de lecture

«Le plan de contre-mesures a un« niveau de recommandation », mais c'est une impression personnelle basée sur l'expérience. ―― Le niveau de recommandation lors de l'intégration dans une équipe est affiché en 3 étapes (: star: ~: star :: star :: star :)

Mesure

JSR-305 Un groupe d'annotations défini pour Software Defect Detection en tant que spécification Java.

Par conséquent, il ne s'agit pas d'une annotation censée fonctionner dans Runtime, mais d'une spécification définie comme une ** fonction auxiliaire ** au moment du développement (par exemple, prise en charge dans les IDE tels que Find Bugs et IntelliJ).

Déclarer si le type de retour est null

Niveau de recommandation :: star :: star :: star:

import javax.annotation.Nullable;

@Nullable
public String createText() {
    // ...

import javax.annotation.Nonnull;

@Nonnull
public String createText() {
    // ...

Il est très important de pouvoir utiliser la fonction d'assistance aux chèques, mais j'ai senti que l'efficacité serait maximisée dans les points suivants lorsque l'on travaillait en équipe.

• L'intention de chaque méthode du concepteur / réalisateur peut être clairement laissée. -Amélioration de la qualité au moment de l'examen en tant qu'effet secondaire
• Réduit l'effort des implémenteurs utilisant des méthodes pour considérer null
• Réduction des vérifications nulles inutiles

Déclarez s'il faut autoriser null dans l'argument

Niveau de recommandation :: étoile:

import javax.annotation.Nullable;
import javax.annotation.Nonnull;

public String createText(@Nonnull String id,
                         @Nullable String option) {
    // ...

Bien que les mêmes avantages que "déclarer si le type de retour est" nul "" peuvent être obtenus, les inconvénients suivants sont évidents pour l'équipe.

• Il est difficile d'ajouter pour tous les arguments ――Parce que c'est gênant, il est facile de devenir un simple cadavre
• L'argument entre dans l'état du festival d'annotation et la visibilité diminue.

Java 8+ standard ʻOptional`

ʻOptional suggère null` comme type de retour

Niveau de recommandation :: étoile:

import java.util.Optional;

public Optional<String> getText() {
   // ...

Java 8 «Optionnel» est mentionné dans de nombreux articles, je n'entrerai donc pas dans les détails. Les raisons pour lesquelles nous ne le recommandons pas ici sont les suivantes.

• Le type ʻOptional` n'est pas une classe sérialisable, donc son utilisation est limitée.
• Les règles sont susceptibles de casser dans les cas où les bibliothèques (en particulier O / R Mapper) ne sont pas prises en charge

■ Référence

• Java 8 "facultatif" ~ Comment gérer null à l'avenir ~
• Résumé de l'utilisation d'Optionnel n'est pas sérialisable

Programmation de représentation

«Programmation d'expression» qui vérifie les conditions préalables introduites dans Master Programmer. C'est très précieux car cela vous permet de laisser le "concept de niveau supérieur" du concepteur / implémenteur sous forme de code.

Tester les hypothèses du programme avec ʻassert`

Niveau de recommandation :: star :: star:

private String createText(String id) {
    assert (id != null) : "id must not be null.";
    // ...

Un exemple typique de programmation express en Java est ʻassert`. Cependant, vous devez être conscient des points suivants dans le code (Programming with assertions | oracle.com Extrait de assert.html)

■ Activer et désactiver les assertions ** Par défaut, les assertions sont désactivées ** au moment de l'exécution. Vous pouvez utiliser deux commutateurs de ligne de commande pour activer / désactiver les assertions. Utilisez les assertions -enable ou -ea pour activer les assertions à différents niveaux de détail.

On peut lire que ʻassert` est juste un moyen auxiliaire pour la déclaration d'intention de l'implémenteur, pas pour lever une exception dans le Runtime du code produit. De plus, si vous lisez attentivement le document officiel, il contiendra des informations importantes telles que les traitements qui ont des effets secondaires, vous devez donc réfléchir attentivement aux points à utiliser lors de l'adoption.

Tirer parti des assertions de la bibliothèque

Niveau de recommandation :: star :: star :: star:

import org.springframework.util.Assert;

public String createText(String id) {
    Assert.notNull(id, "ID must not be null.");
    // ...

Pour Spring Framework ʻorg.springframework.util.Assert` L'utilisation est-ce.

Contrairement à Java Assertion, il déclenche une exception même au Runtime. C'est une simplification de la vérification des null, mais cela fonctionne également avec Runtime, vous pouvez donc laisser une déclaration d'intention très forte pour l'implémenteur dans votre code.

Défense indirecte «nulle»

Déclarez la variable finale pour la rendre immuable

Niveau de recommandation :: star :: star:

public String createText(final String id) {
    // ...

public String createText(String id) {
    final String prefix = something(id);
    // ...

L'utilisation de «final» ne semble pas être directement liée à «null». Cependant, en combinaison avec la garantie non-«nul» dans Assertion, vous pouvez presque complètement garantir non-nul »dans votre propre méthode. En conséquence, vous pouvez supprimer en toute confiance les traitements inutiles tels que "Je ne sais pas ce qui va arriver, alors vérifiez" null "pour le moment" dans le traitement intermédiaire.

Rendre la collection immuable

Niveau de recommandation :: star :: star:

Norme Java

import java.util.Collections;

public String createText() {
    List immutables = Collections.singletonList("value1", "value2");
    // ...

import java.util.Collections;

public String createText() {
    Map<String, String> immutables = Collections.singletonMap("key1", "value1");
    // ...

import java.util.Collections;

public List<Store> fetchStores() {
   List<Store> stores  = findAll();
   
   return Collections.unmodifiableCollection(stores);

Guava

import com.google.common.collect.ImmutableMap;

public String createText() {
    Map<String, String> immutables = ImmutableMap.of("key1", "value1", "key2", "value2");
    // ...

import com.google.common.collect.ImmutableList;

public String createText() {
    List<String> immutables = ImmutableList.of("value1", "value2");
    // ...

C'est une défense assez locale en ce qui concerne les collections immuables.

Cela réduit le risque de mélanger des éléments "null" dans une collection une fois créée, dans le but de prendre en charge les exceptions "null" lors du traitement intermédiaire ultérieur. C'est sobre, mais il devrait être incorporé autant que possible.

exemple

Voyons à quel point la quantité d'informations diffère réellement avant / après l'application.

before

public class StoreService {
    
    public Store fetchStore(String storeId){
        // ...
    }

    public List<Store> fetchSisterStores(String storeId){
        // ...
    }

    public List<Coupon> fetchCoupons(String storeId,
                                         List<Category> categories){
        // ...
    }
}

after

public class StoreService {

    @Nonnull
    public Store fetchStore(final String storeId) {
        Assert.notNull(storeId, "store-id must not be null.");
        // ...

    }

    @Nullable
    public List<Store> fetchSisterStores(final String storeId) {
        Assert.notNull(storeId, "store-id must not be null.");

        // ...
    }

    @Nonnull
    public List<Coupon> fetchCoupons(final String storeId,
                                     final List<Category> categories) {
        Assert.notNull(storeId,    "store-id must not be null.");
        Assert.notNull(categories, "categories must not be null.");

        // ...
    }
}

N'est-ce pas un code plus expressif? Juste en lisant quelques lignes avant et après la signature, vous pouvez instantanément prendre la plupart des exemples, et le code est convivial.

Du point de vue de l'évaluateur, la différence dans les spécifications du type «List» retourné par «fetchSisterStores (...)» et «fetchCoupons (...)» est plus apparente, et la qualité de l'avis est susceptible de s'améliorer.

Résumé

Choisissez les contre-mesures «nul» en équipe et réduisez au maximum la dette technique causée par «null»! Et réalisons les mérites suivants avec toute l'équipe!

• Amélioration de la lisibilité du code
• Amélioration de la qualité des avis
• Réduction des nuits lorsque l'oreiller est mouillé avec Nurpo

Ayons une bonne vie «nulle»!