mvc - spring traduccion

Spring PropertyPlaceholderConfigurer y context: property-placeholder

Question

Tengo la siguiente declaración de frijol:

 <bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>WEB-INF/classes/config/properties/database.properties</value>
<value>classpath:config/properties/database.properties</value>
</list>
</property>
<property name="ignoreResourceNotFound" value="true"/>
</bean>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>

Ahora quiero cambiar el PropertyPlaceholderConfigurer anterior al siguiente formato:

<context:component-scan base-package="org.example.config"/>
<util:properties id="jdbcProperties"
location="classpath:config/properties/database.properties"/>

1. ignoreResourceNotFound ignorará la propiedad mientras se ejecuta. por ejemplo: Al probar la aplicación WEB-INF / .., la ruta ignorará (ya que el proyecto y el archivo de propiedad están en src / main / resources / ...), mientras se lanza la aplicación web, otra propiedad ignorará la ruta, necesito implementarlo con el formato anterior.
2. debería ser capaz de agregar múltiples archivos de propiedades como database.properties, test.properties, etc.
3. en Spring 3, ¿puedo usar la anotación en lugar de estos archivos xml para cargar DB, cómo puedo hacerlo? ya que estoy usando solo un archivo xml (dado anteriormente) para cargar cosas db.

Estoy usando el marco de Spring 3.

Answer 1

Lo siguiente funcionó para mí:
<context:property-placeholder location="file:src/resources/spring/AppController.properties"/>

De alguna manera, "classpath: xxx" no está recogiendo el archivo.

Answer 2

Primero, no necesita definir ambas ubicaciones. Solo use classpath:config/properties/database.properties . En WAR, WEB-INF/classes es una entrada classpath, por lo que funcionará perfectamente.

Después de eso, creo que lo que quieres decir es que quieres usar la configuración basada en esquemas de Spring para crear un configurador . Eso sería así:

<context:property-placeholder location="classpath:config/properties/database.properties"/>

Tenga en cuenta que ya no necesita "ignorarResourceNotFound". Si necesita definir las propiedades por separado usando util:properties :

<context:property-placeholder properties-ref="jdbcProperties" ignore-resource-not-found="true"/>

Sin embargo, generalmente no hay ninguna razón para definirlos por separado.

Answer 3

<context:property-placeholder ... /> es el XML equivalente al PropertyPlaceholderConfigurer. Entonces, prefiero eso. El <util:properties/> simplemente crea una instancia de java.util.Properties que puede inyectar.

En Spring 3.1 (no 3.0 ...) puedes hacer algo como esto:

@Configuration
@PropertySource("/foo/bar/services.properties")
public class ServiceConfiguration {
@Autowired Environment environment;
@Bean public javax.sql.DataSource dataSource( ){
String user = this.environment.getProperty("ds.user");
...
}
}

En Spring 3.0, puede "acceder" a las propiedades definidas utilizando el mecanismo PropertyPlaceHolderConfigurer utilizando las anotaciones SpEl:

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

Si desea eliminar todo el XML, simplemente registre el PropertyPlaceholderConfigurer manualmente usando la configuración de Java. Prefiero el enfoque 3.1. Pero, si está utilizando el enfoque de Spring 3.0 (ya que 3.1 aún no es GA ...), ahora puede definir el XML anterior de esta manera:

@Configuration
public class MySpring3Configuration {
@Bean
public static PropertyPlaceholderConfigurer configurer() {
PropertyPlaceholderConfigurer ppc = ...
ppc.setLocations(...);
return ppc;
}
@Bean
public class DataSource dataSource(
@Value("${ds.user}") String user,
@Value("${ds.pw}") String pw,
...) {
DataSource ds = ...
ds.setUser(user);
ds.setPassword(pw);
...
return ds;
}
}

Tenga en cuenta que PPC se define utilizando un método de definición de bean static . Esto es necesario para asegurarse de que el bean se registra temprano, porque el PPC es un BeanFactoryPostProcessor ; puede influir en el registro de los beans en el contexto, por lo que necesariamente debe registrarse antes que todo lo demás.