spring - propertysourcesplaceholderconfigurer - ¿Cómo leer valores del archivo de propiedades?

read properties file java

Question

Estoy usando la primavera. Necesito leer los valores del archivo de propiedades. Este es el archivo de propiedades interno, no el archivo de propiedades externo. El archivo de propiedades puede ser el siguiente.

some.properties ---file name. values are below.

abc = abc
def = dsd
ghi = weds
jil = sdd

Necesito leer esos valores del archivo de propiedades no de manera tradicional. ¿Cómo lograrlo? ¿Hay algún enfoque más reciente con la primavera 3.0?

Answer 1

Aquí hay una respuesta adicional que también fue de gran ayuda para que yo entienda cómo funcionó: http://www.javacodegeeks.com/2013/07/spring-bean-and-propertyplaceholderconfigurer.html

cualquier bean BeanFactoryPostProcessor debe ser declarado con un modificador estático

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

Answer 2

Configure PropertyPlaceholder en su contexto:

<context:property-placeholder location="classpath*:my.properties"/>

Luego te refieres a las propiedades en tus beans:

@Component
class MyClass {
  @Value("${my.property.name}")
  private String[] myValues;
}

EDITAR: actualizó el código para analizar la propiedad con múltiples valores separados por comas:

my.property.name=aaa,bbb,ccc

Si eso no funciona, puede definir un bean con propiedades, inyectarlo y procesarlo manualmente:

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

y el frijol:

@Component
class MyClass {
  @Resource(name="myProperties")
  private Properties myProperties;

  @PostConstruct
  public void init() {
    // do whatever you need with properties
  }
}

Answer 3

En la clase de configuración

@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;
   }
}

Answer 4

Hay varias maneras de lograr lo mismo. A continuación se presentan algunas formas comunes utilizadas en primavera:

1. Usando PropertyPlaceholderConfigurer
2. Usando PropertySource
3. Usando ResourceBundleMessageSource

4. Usando PropertiesFactoryBean

   y muchos más........................

Asumir ds.type es la clave en su archivo de propiedad.

Usando PropertyPlaceholderConfigurer

Register PropertyPlaceholderConfigurer bean-

<context:property-placeholder location="classpath:path/filename.properties"/>

o

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

o

@Configuration
public class SampleConfig {
 @Bean
 public static PropertySourcesPlaceholderConfigurer placeHolderConfigurer() {
  return new PropertySourcesPlaceholderConfigurer();
  //set locations as well.
 }
}

Después de registrar PropertySourcesPlaceholderConfigurer , ahora puede acceder a value-

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

Usando PropertySource

En la última versión de primavera no es necesario registrar PropertyPlaceHolderConfigurer con @PropertySource , encontré un buen link para comprender la versión de compatibilidad.

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

Usando ResourceBundleMessageSource

Register Bean-

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

Valor de acceso

((ApplicationContext)context).getMessage("ds.type", null, null);

o

@Component
public class BeanTester {
    @Autowired MessageSource messageSource; 
    public void execute(){
        String attr = this.messageSource.getMessage("ds.type", null, null);
    }
}

Usando PropertiesFactoryBean

Register Bean-

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

Instancia de Wire Properties en su clase-

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

Answer 5

Necesita poner un bean PropertyPlaceholderConfigurer en el contexto de su aplicación y establecer su propiedad de ubicación.

Vea los detalles aquí: http://www.zparacha.com/how-to-read-properties-file-in-spring/

Puede que tenga que modificar un poco el archivo de propiedad para que esto funcione.

Espero eso ayude.

Answer 6

Recomiendo leer este enlace https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html de los documentos de SpringBoot sobre cómo inyectar configuraciones externas. No solo hablaban de recuperar de un archivo de propiedades sino también de archivos YAML e incluso JSON. Lo encontré útil. Espero que ustedes también.

Answer 7

Si necesita leer manualmente un archivo de propiedades sin usar @Value.

Gracias por la bien escrita página de 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;
    }
}

Answer 8

 [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>