L'accès par programme aux biens créés par la propriété de l'espace réservé

@Value

annotation travaille sur de nouvelles versions de Printemps (testé sur v3.2.2)
Voici comment il est fait:

1. Carte votre fichier de propriétés de configuration spring fichier

   <!--Import Info:
   xmlns:context="http://www.springframework.org/schema/context"
   http://www.springframework.org/schema/context 
   http://www.springframework.org/schema/context/spring-context-3.2.xsd-->
   
   <context:property-placeholder location="classpath:/app-config.properties" />

2. Créer app-config.propriétés à l'intérieur (racine) de votre dossier source

   my.property=test
   my.property2=test2

3. Créer une classe contrôleur

   @Controller
   public class XRDSBuilder
   {
       @Value("${my.property}")
       private String myProperty;
   
       public String getMyProperty() { return myProperty; }
   }

Printemps automatiquement le contenu de mon.propriété à votre variable à l'intérieur du contrôleur de

La cartographie à une liste

La valeur de la propriété:

my.list.property=test,test2,test3

Classe de contrôleur de configuration:

@Value("#{'${my.list.property}'.split(',')}")
private List<String> myListProperty;

Cartographie avancée

@Component("PropertySplitter")
public class PropertySplitter {
/**
* Example: one.example.property = KEY1:VALUE1,KEY2:VALUE2
*/
public Map<String, String> map(String property) {
return this.map(property, ",");
}
/**
* Example: one.example.property = KEY1:VALUE1.1,VALUE1.2;KEY2:VALUE2.1,VALUE2.2
*/
public Map<String, List<String>> mapOfList(String property) {
Map<String, String> map = this.map(property, ";");
Map<String, List<String>> mapOfList = new HashMap<>();
for (Entry<String, String> entry : map.entrySet()) {
mapOfList.put(entry.getKey(), this.list(entry.getValue()));
}
return mapOfList;
}
/**
* Example: one.example.property = VALUE1,VALUE2,VALUE3,VALUE4
*/
public List<String> list(String property) {
return this.list(property, ",");
}
/**
* Example: one.example.property = VALUE1.1,VALUE1.2;VALUE2.1,VALUE2.2
*/
public List<List<String>> groupedList(String property) {
List<String> unGroupedList = this.list(property, ";");
List<List<String>> groupedList = new ArrayList<>();
for (String group : unGroupedList) {
groupedList.add(this.list(group));
}
return groupedList;
}
private List<String> list(String property, String splitter) {
return Splitter.on(splitter).omitEmptyStrings().trimResults().splitToList(property);
}
private Map<String, String> map(String property, String splitter) {
return Splitter.on(splitter).omitEmptyStrings().trimResults().withKeyValueSeparator(":").split(property);
}
}

La valeur de la propriété:

my.complex.property=test1:value1,test2:value2

Classe de contrôleur:

@Value("#{PropertySplitter.map('${my.complex.property}')}")
Map<String, String> myComplexProperty;

Le printemps succède à l'Inversion De Contrôle d'approche, ce qui signifie que nous pouvons simplement injecter propriété particulière dans POJO. Mais il ya certains cas, lorsque vous souhaitez accéder à la propriété donnée par nom directement à partir de votre code - certains pourraient voir comme anti-modèle - c'est très vrai, mais permet de se concentrer sur la manière de le faire.

La PropertiesAccessor ci-dessous permet d'accéder aux propriétés chargé par Property Placeholder et encapsule le conteneur de choses spécifiques. Il met également en cache propriétés à cause d'appel sur AbstractBeanFactory#resolveEmbeddedValue(String) n'est pas bon marché.

@Named 
public class PropertiesAccessor {
private final AbstractBeanFactory beanFactory;
private final Map<String,String> cache = new ConcurrentHashMap<>(); 
@Inject 
protected PropertiesAccessor(AbstractBeanFactory beanFactory) {
this.beanFactory = beanFactory; 
} 
public  String getProperty(String key) { 
if(cache.containsKey(key)){ 
return cache.get(key); 
} 
String foundProp = null; 
try { 
foundProp = beanFactory.resolveEmbeddedValue("${" + key.trim() + "}");        
cache.put(key,foundProp);        
} catch (IllegalArgumentException ex) { 
//ok - property was not found 
} 
return foundProp; 
} 
}

Créer des haricots pour vos propriétés avant de les mettre dans la propriété de l'espace réservé pour que les propriétés facile d'accès dans le code.

Ex:

<bean id="configProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
<property name="resources" value="classpath:META-INF/spring/config.properties" />
</bean>
<context:property-placeholder properties-ref="configProperties" ignore-unresolvable="true"/>

Code:

@Autowired
private PropertiesFactoryBean configProperties;

Vous pouvez également utiliser @Resource(name="configProperties")

Cela fonctionne si vous avez besoin de numériser plusieurs emplacements pour vos propriétés ...

<bean id="yourProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
<property name="locations">
<array value-type="org.springframework.core.io.Resource">
<value>classpath:yourProperties.properties</value>
<value>file:../conf/yourProperties.properties</value>
<value>file:conf/yourProperties.properties</value>
<value>file:yourProperties.properties</value>
</array>
</property>
<property name="ignoreResourceNotFound" value="true" />
</bean>
<context:property-placeholder properties-ref="yourProperties" ignore-unresolvable="true"/>

Puis dans vos classes réelles ...

@Autowired
Properties yourProperties;

Testé à l'aide de Printemps 5.1.4