Comment lire les valeurs du fichier de propriétés?
J'utilise le printemps. J'ai besoin de lire les valeurs du fichier de propriétés. Il s'agit d'un fichier de propriétés internes et non d'un fichier de propriétés externes. Fichier de propriétés peut être comme ci-dessous.
some.properties ---file name. values are below.
abc = abc
def = dsd
ghi = weds
jil = sdd
J'ai besoin de lire ces valeurs à partir du fichier de propriétés Pas de manière traditionnelle. Comment faire? Existe-t-il une dernière approche avec spring 3.0?
8 réponses
Configurez PropertyPlaceholder dans votre contexte:
<context:property-placeholder location="classpath*:my.properties"/>
Ensuite, vous vous référez aux propriétés de vos haricots:
@Component
class MyClass {
@Value("${my.property.name}")
private String[] myValues;
}
EDIT: mise à jour du code pour analyser la propriété avec des valeurs séparées par des virgules multiples:
my.property.name=aaa,bbb,ccc
Si cela ne fonctionne pas, vous pouvez définir un bean avec des propriétés, l'injecter et le traiter manuellement:
<bean id="myProperties"
class="org.springframework.beans.factory.config.PropertiesFactoryBean">
<property name="locations">
<list>
<value>classpath*:my.properties</value>
</list>
</property>
</bean>
Et le haricot:
@Component
class MyClass {
@Resource(name="myProperties")
private Properties myProperties;
@PostConstruct
public void init() {
// do whatever you need with properties
}
}
Dans la classe de configuration
@Configuration
@PropertySource("classpath:/com/myco/app.properties")
public class AppConfig {
@Autowired
Environment env;
@Bean
public TestBean testBean() {
TestBean testBean = new TestBean();
testBean.setName(env.getProperty("testbean.name"));
return testBean;
}
}
Il existe différentes façons d'atteindre la même chose,ci-dessous sont quelques moyens couramment utilisés au printemps -
- Utiliser PropertyPlaceholderConfigurer
- Utiliser PropertySource
- Utilisation De ResourceBundleMessageSource
-
À L'Aide De PropertiesFactoryBean
Et beaucoup plus........................
en supposant que ds.type est la clé dans votre fichier de propriété.
À l'Aide de PropertyPlaceholderConfigurer
Registre PropertyPlaceholderConfigurer bean -
<context:property-placeholder location="classpath:path/filename.properties"/>
Ou
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations" value="classpath:path/filename.properties" ></property>
</bean>
Ou
@Configuration
public class SampleConfig {
@Bean
public static PropertySourcesPlaceholderConfigurer placeHolderConfigurer() {
return new PropertySourcesPlaceholderConfigurer();
//set locations as well.
}
}
Après avoir enregistré PropertySourcesPlaceholderConfigurer, Vous pouvez maintenant accéder à value -
@Value("${ds.type}")private String attr;
À l'Aide de PropertySource
Dans la dernière version de printemps pas besoin de s'inscrire PropertyPlaceHolderConfigurer avec @PropertySource, j'ai trouvé un bon lien pour comprendre la compatibilité de la version -
@PropertySource("classpath:path/filename.properties")
@Component
public class BeanTester {
@Autowired Environment environment;
public void execute(){
String attr = this.environment.getProperty("ds.type");
}
}
À l'Aide de ResourceBundleMessageSource
Registre Bean -
<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basenames">
<list>
<value>classpath:path/filename.properties</value>
</list>
</property>
</bean>
Accès Valeur -
((ApplicationContext)context).getMessage("ds.type", null, null);
Ou
@Component
public class BeanTester {
@Autowired MessageSource messageSource;
public void execute(){
String attr = this.messageSource.getMessage("ds.type", null, null);
}
}
À l'Aide de PropertiesFactoryBean
Registre Bean -
<bean id="properties"
class="org.springframework.beans.factory.config.PropertiesFactoryBean">
<property name="locations">
<list>
<value>classpath:path/filename.properties</value>
</list>
</property>
</bean>
Fil propriétés instance dans votre classe -
@Component
public class BeanTester {
@Autowired Properties properties;
public void execute(){
String attr = properties.getProperty("ds.type");
}
}
Voici une réponse supplémentaire qui m'a également beaucoup aidé à comprendre comment cela a fonctionné: http://www.javacodegeeks.com/2013/07/spring-bean-and-propertyplaceholderconfigurer.html
Tous les beans BeanFactoryPostProcessor doivent être déclarés avec unstatique , modificateur
@Configuration
@PropertySource("classpath:root/test.props")
public class SampleConfig {
@Value("${test.prop}")
private String attr;
@Bean
public SampleService sampleService() {
return new SampleService(attr);
}
@Bean
public static PropertySourcesPlaceholderConfigurer placeHolderConfigurer() {
return new PropertySourcesPlaceholderConfigurer();
}
}
Vous devez placer un bean PropertyPlaceholderConfigurer dans votre contexte d'application et définir sa propriété location.
Voir les détails ici: http://www.zparacha.com/how-to-read-properties-file-in-spring/
Vous devrez peut-être modifier un peu votre fichier de propriétés pour que cette chose fonctionne.
J'espère que ça aide.
Si vous devez lire manuellement un fichier de propriétés sans utiliser @Value.
Merci pour la page bien écrite par Lokesh Gupta: Blog
package utils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.ResourceUtils;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import java.io.File;
public class Utils {
private static final Logger LOGGER = LoggerFactory.getLogger(Utils.class.getName());
public static Properties fetchProperties(){
Properties properties = new Properties();
try {
File file = ResourceUtils.getFile("classpath:application.properties");
InputStream in = new FileInputStream(file);
properties.load(in);
} catch (IOException e) {
LOGGER.error(e.getMessage());
}
return properties;
}
}
[project structure]: http://i.stack.imgur.com/RAGX3.jpg
-------------------------------
package beans;
import java.util.Properties;
import java.util.Set;
public class PropertiesBeans {
private Properties properties;
public void setProperties(Properties properties) {
this.properties = properties;
}
public void getProperty(){
Set keys = properties.keySet();
for (Object key : keys) {
System.out.println(key+" : "+properties.getProperty(key.toString()));
}
}
}
----------------------------
package beans;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
ApplicationContext ap = new ClassPathXmlApplicationContext("resource/spring.xml");
PropertiesBeans p = (PropertiesBeans)ap.getBean("p");
p.getProperty();
}
}
----------------------------
- driver.properties
Driver = com.mysql.jdbc.Driver
url = jdbc:mysql://localhost:3306/test
username = root
password = root
----------------------------
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd">
<bean id="p" class="beans.PropertiesBeans">
<property name="properties">
<util:properties location="classpath:resource/driver.properties"/>
</property>
</bean>
</beans>
Je vous recommande de lire ce lien https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html de SpringBoot docs sur l'injection de configs externes. Ils n'ont pas seulement parlé de la récupération à partir d'un fichier de propriétés, mais aussi des fichiers YAML et même JSON. Je l'ai trouvé utile. J'espère que vous aussi.