web-dev-qa-db-fra.com

Spring Util: Injection de propriétés via des annotations dans un bean

Si j'ai 2 fichiers .properties configurés dans mon XML Spring comme suit:

<util:properties id="serverProperties" location="file:./applications/MyApplication/server.properties"/>
<util:properties id="someConfig" location="file:./applications/MyApplication/config.properties"/>

Comment puis-je injecter via des annotations ces fichiers de propriétés dans un bean avec Java.util.Properties?

Comment puis-je récupérer des propriétés spécifiques via des annotations Spring?

À votre santé!

javaspringpropertiesdependency-injection
30
NightWolf
@Autowired
@Qualifier("serverProperties")
private Properties serverProperties;
@Autowired
@Qualifier("someConfig")
private Properties otherProperties;

ou

@Resource(name = "serverProperties")
private Properties serverProperties;
@Resource(name = "someConfig")
private Properties otherProperties;

En règle générale, @Autowired est utilisé pour le câblage automatique par type dans Spring et @Resource est utilisé pour le nom. @ Autowired + @ Qualifier peut doubler en tant que câblage automatique par nom, mais il est vraiment destiné au câblage automatique par type avec la possibilité de affiner le type .

46
Ryan Stewart

Comme cette question a beaucoup de succès. J'ai pensé qu'il serait utile de souligner une autre option en utilisant SpEL (Spring Expression Language) - si vous avez besoin de propriétés spécifiques, elles peuvent être injectées en utilisant l'annotation @Value sur des propriétés spécifiques du bean;

class SomeClass {
   @Value("#{serverProperties['com.svr.prop']}")
   private String aServerCfgProperty;

   @Value("#{someConfig['another.config.setting']}")
   private String someOtherProperty;
}

Vous n'avez pas besoin d'utiliser la syntaxe d'indexation ['index.val'] vous pouvez l'obtenir directement;

@Value("#{someConfig}")
private Properties someConfig

@Value("#{serverProperties}")
private Properties svrProps;

J'ai trouvé cela plutôt utile et j'ai abandonné l'utilisation de l'objet de propriétés directement injecté via @ Resource/@ Autowired.

Une autre bonne raison d'utiliser le @Value avec un objet Propriétés indexé est que certains IDE (par exemple IntelliJ) peuvent refactoriser les noms de propriété réels si vous avez également le fichier .properties dans le projet qui est Nice. Une autre astuce consiste à utiliser quelque chose comme EProperties (qui étend l'objet natif Java Properties) si vous voulez faire l'inclusion/l'imbrication/la substitution dans les fichiers de propriétés sans utiliser Spring PropertiesPlaceholderConfigurer classe (qui malheureusement n'expose pas ses propriétés - pour utiliser l'indexation SpEL ['key'] le bean doit être une instance de Map<> c'est-à-dire étendre la carte que fait l'objet Java Properties) ...

Enfin, une autre fonctionnalité intéressante de SpEL est que vous pouvez accéder directement aux propriétés des beans. Dites par exemple si SomeClass dans l'exemple ci-dessus était un bean Spring, par exemple someClass puis dans AnotherBeanClass nous pourrions avoir;

@Value("#{someClass.someOtherProperty}")
private String injectedBeanProp

Vous pouvez également appeler une méthode getter:

@Value("#{someClass.getSomeOtherProperty()}")
private String injectedBeanProp

Voir le guide SpEL ici; http://static.springsource.org/spring/docs/3.1.x/spring-framework-reference/htmlsingle/spring-framework-reference.html#expressions

16
NightWolf

Vous pouvez utiliser @PropertySource

@Configuration
@PropertySource(name = "someName", value = {"classpath:a.properties", "classpath:b.properties"})
public class MyConfiguration {
}
2
Venky

Fichier XMl

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:mvc="http://www.springframework.org/schema/mvc"
 xmlns:util="http://www.springframework.org/schema/util"
 xsi:schemaLocation="
 http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-4.0.xsd
 http://www.springframework.org/schema/mvc
 http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
 http://www.springframework.org/schema/util 
 http://www.springframework.org/schema/util/spring-util-4.0.xsd">
    <context:component-scan base-package="com.sha.home" />
    <mvc:annotation-driven/>
    <util:properties id="dbProp" location="classpath:db.properties" />
    <!-- <context:property-placeholder location="classpath:db.properties"/> -->

</beans>

dans Java file @Value ("# {dbProp}") private Properties dbProperties;

System.out.println ("urllll" + dbProperties.getProperty ("jdbc.url"));

1
sharath

La plupart du temps, j'encapsule toutes les propriétés dans un seul utilitaire et utilisé dans mes applications. De cette façon, vous n'avez pas à vous soucier/gérer chaque fichier de propriétés dans la couche d'application. Autowired setProps (...) lit tout ce que vous avez chargé til: properties dans la liste props.

import Java.util.List;
import Java.util.Properties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class AppProperiesProcessor {

private List<Properties> props;
private Properties mergedProperties;

@Autowired
public final void setProps(List<Properties> props) {
    this.props = props;
}

public String getProp(final String keyVal) {

    if (null == this.mergedProperties) {
        this.mergedProperties = new Properties();

        for (Properties prop : this.props) {
            this.mergedProperties.putAll(prop);
        }
    }
    return mergedProperties.getProperty(keyVal);
  } 
}
0
mahesh