Puis-je définir null comme valeur par défaut pour une @Value au printemps?

J'utilise actuellement l'annotation @Value Spring 3.1.x comme ceci:

@Value("${stuff.value:}")
private String value;

Cela place une chaîne vide dans la variable si l'attribut n'est pas présent. Je voudrais avoir null comme valeur par défaut au lieu d'une chaîne vide. Bien sûr, je souhaite également éviter une erreur lorsque la propriété stuff.value n'est pas définie.

Vous devez définir la valeur null de PropertyPlaceholderConfigurer . Pour l'exemple, j'utilise la chaîne, @nullmais vous pouvez également utiliser la chaîne vide comme nullValue.

<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <!-- config the location(s) of the properties file(s) here -->
    <property name="nullValue" value="@null" />
</bean>

Vous pouvez maintenant utiliser la chaîne @nullpour représenter la nullvaleur

@Value("${stuff.value:@null}")
private String value;

Remarque: l'espace de noms de contexte ne prend pas en charge la valeur nulle pour le moment. Vous ne pouvez pas utiliser

<context:property-placeholder null-value="@null" ... />

Testé avec Spring 3.1.1

C'est vraiment vieux, mais vous pouvez utiliser Spring EL maintenant, par exemple

@Value("${stuff.value:#{null}}")

Voir cette question .

Merci à @vorburger:

@Value("${email.protocol:#{null}}")
String protocol;

définira la valeur de la chaîne à null sans aucune autre configuration.

Je donne du crédit à @nosebrain car je ne connaissais pas la "valeur nulle", mais je préfère éviter d'utiliser des valeurs nulles, d'autant plus que c'est difficile à représenter nulldans un fichier de propriétés.

Mais voici une alternative utilisant null sans null-valuepour cela fonctionnera avec n'importe quel espace réservé de propriété.

public class MyObject {

   private String value;

   @Value("${stuff.value:@null}")
   public void setValue(String value) {
      if ("@null".equals(value)) this.value = null;
      else this.value = value;
   }
}

Personnellement, je préfère mon chemin parce que peut-être plus tard vous voudrez stuff.valueêtre une valeur séparée par des virgules ou peut-être enum, le commutateur est plus facile. C'est aussi plus facile à tester unitaire :)

EDIT: basé sur vos commentaires sur l'utilisation des énumérations et mon opinion de ne pas utiliser null.

@Component
public class MyObject {

    @Value("${crap:NOTSET}")
    private Crap crap;

    public enum Crap {
        NOTSET,
        BLAH;
    }
}

Ce qui précède fonctionne très bien pour moi. Vous évitez null. Si vos fichiers de propriétés veulent définir explicitement qu'ils ne veulent pas le gérer, vous le faites ( mais vous n'avez même pas à le spécifier car il sera par défaut NOTSET ).

crap=NOTSET

nullest très mauvais et est différent de NOTSET. Cela signifie que le test de ressort ou d'unité ne l'a pas réglé, c'est pourquoi il y a une différence à mon humble avis. J'utiliserais probablement toujours la notation de setter (exemple précédent) car son test unitaire est plus facile (les variables privées sont difficiles à définir dans un test unitaire).

Au cas où vous auriez besoin d'injecter une chaîne vide (longueur 0) "" comme @Value default - utilisez SPEL (Spring Expression Language) comme suit:

@Value("${index.suffix:#{''}}") 
private String indexSuffix;

# {''} vous donne juste une chaîne vide comme la valeur par défaut de @ Value.

par yl