primavera Util: Propiedades de inyección a través de anotaciones en un grano de

Question

Si tengo 2 .properties archivos de configuración XML en mi primavera como tan:

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

Como puedo inyectar a través de anotaciones archivos de estas propiedades en un frijol con java.util.Properties?

¿Cómo puedo obtener propiedades específicas a través de las anotaciones de Spring?

¡Salud!

Answer 1

@Autowired 
@Qualifier("serverProperties") 
private Properties serverProperties; 
@Autowired 
@Qualifier("someConfig") 
private Properties otherProperties; 

o

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

Típicamente, @Autowired se utiliza para autowiring por tipo en el resorte, y @Resource se utiliza para por nombre. @ Autowired + @ Qualifier puede doblar como automático de nombre propio, pero en realidad está destinado para el autoenvío de tipo con la capacidad de fine-tune the type.

Answer 2

Puede utilizar @PropertySource

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

Answer 3

Como esta pregunta tiene una gran cantidad de golpes. Pensé que valdría la pena señalar otra opción utilizando SpEL (Spring Expression Language): si necesita propiedades específicas, puede inyectarlas utilizando la anotación @Value en propiedades de beans específicos;

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

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

Usted no necesita utilizar la sintaxis de indexación ['index.val'] sólo puede conseguirlo directamente;

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

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

He encontrado que esto más bien útil y movido lejos de usar las propiedades de objeto directamente inyectado a través de @ Recursos/@ Autowired.

Otro buen motivo para usar el @Value con un objeto Propiedades indexado es que algunos IDEs (por ejemplo, IntelliJ) pueden refactorizar los nombres de propiedad reales si también tiene el archivo .properties en el proyecto. Otro consejo es usar algo como EProperties (que amplía el objeto nativo de Propiedades de Java) si desea incluir/anidar/sustituir en archivos de propiedades sin usar la clase PropertiesPlaceholderConfigurer de Spring (que lamentablemente no expone sus propiedades - para usar la indexación de SpEL ['key'] necesita ser una instancia de Map<> es decir, ampliar el mapa que hace el objeto Propiedades de Java) ...

Finalmente, otra característica interesante con SpEL es que puede acceder directamente a las propiedades de los granos. Por ejemplo, digamos si SomeClass en el ejemplo anterior era un Spring Bean, p. Ej. someClass luego en AnotherBeanClass podríamos tener;

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

También puede llamar a un método de obtención:

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

Consulte la guía SpEL aquí; http://static.springsource.org/spring/docs/3.1.x/spring-framework-reference/htmlsingle/spring-framework-reference.html#expressions

Answer 4

La mayor parte del tiempo encapsulo todas las propiedades en una utilidad y las utilizo en mis aplicaciones. De esta forma, no necesita preocuparse/administrar cada archivo de propiedades en la capa de la aplicación. Autowired setProps (...) lee todo lo que cargó util: propiedades en la lista de accesorios.

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

Answer 5

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

en el archivo java @Valor ("# {} DBPROP") Properties dbProperties privadas;

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