web-dev-qa-db-fra.com

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. Ce fichier de propriétés interne n'est pas le fichier de propriétés externe. Le 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

Je dois lire ces valeurs à partir du fichier de propriétés de manière non traditionnelle. Comment y arriver? Y at-il une dernière approche avec le printemps 3.0?

springproperties-file
108
user1016403

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: a mis à jour le code pour analyser la propriété avec plusieurs valeurs séparées par des virgules:

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
  }
}
180
mrembisz

En 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;
   }
}
38
mokshino

Il y a différentes façons d'atteindre le même objectif. Vous trouverez ci-dessous quelques moyens couramment utilisés au printemps.

  1. En utilisant PropertyPlaceholderConfigurer 
  2. Using PropertySource 
  3. En utilisant ResourceBundleMessageSource 

  4. En utilisant PropertiesFactoryBean

    et beaucoup plus........................

En supposant que ds.type est la clé de votre fichier de propriétés.

Utilisation de PropertyPlaceholderConfigurer

Enregistrez 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 accéder à la valeur-

@Value("${ds.type}")private String attr;

Utilisation de PropertySource

Dans la dernière version du printemps, vous n'avez pas besoin d'enregistrer PropertyPlaceHolderConfigurer avec @PropertySource, j'ai trouvé un bon link pour comprendre la compatibilité des versions- 

@PropertySource("classpath:path/filename.properties")
@Component
public class BeanTester {
    @Autowired Environment environment; 
    public void execute() {
        String attr = this.environment.getProperty("ds.type");
    }
}

Utilisation de ResourceBundleMessageSource

Enregistrer Bean-

<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
  <property name="basenames">
    <list>
      <value>classpath:path/filename.properties</value>
    </list>
  </property>
</bean>

Valeur d'accès

((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);
    }
}

Utilisation de PropertiesFactoryBean

Enregistrer Bean-

<bean id="properties"
      class="org.springframework.beans.factory.config.PropertiesFactoryBean">
  <property name="locations">
    <list>
      <value>classpath:path/filename.properties</value>
    </list>
  </property>
</bean>

Installez Wire Properties dans votre classe

@Component
public class BeanTester {
    @Autowired Properties properties; 
    public void execute() {
        String attr = properties.getProperty("ds.type");
    }
}
31
user4768611

Voici une réponse supplémentaire qui m'a également beaucoup aidé à comprendre comment cela fonctionnait: http://www.javacodegeeks.com/2013/07/spring-bean-and-propertyplaceholderconfigurer.html

tous les beans BeanFactoryPostProcessor doivent être déclarés avec un modificateur static

@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();
 }
}
25
Michael Técourt

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é pour que cela fonctionne.

J'espère que ça aide.

6
instanceOfObject

Si vous devez lire manuellement un fichier de propriétés sans utiliser @Value.

Merci pour la page bien écrite de Lokesh Gupta: Blog

 enter image description here 

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;
    }
}
6
John

Une autre méthode consiste à utiliser un ResourceBundle . En gros, vous obtenez le paquet en utilisant son nom sans les '.properties'

private static final ResourceBundle resource = ResourceBundle.getBundle("config");

Et vous récupérez n'importe quelle valeur en utilisant ceci:

private final String prop = resource.getString("propName");
0
Miluna

Je vous recommande de lire ce lien https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html depuis les documents SpringBoot sur l’injection de configurations externes. Ils ne parlent pas seulement de récupérer à partir d'un fichier de propriétés mais également de fichiers YAML et même JSON. J'ai trouvé ça utile. J'espère que vous aussi. 

0
Josh Uzo
 [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>
0
Sangram Badi