Jak mogę nakazać Springowi użycie mapy Java do rozwiązania zastępczego obiektu?

Question

Mam Map<String, String> i chciałbym powiedzieć Spring, aby użył tego przy tworzeniu fasoli i rozwiązywaniu obiektów zastępczych. Jaki jest najłatwiejszy sposób na zrobienie tego? Oto przykład:

@Component 
public class MyClass { 
    private String myValue; 

    @Autowired 
    public MyClass(@Value("${key.in.map}") String myValue) { 
     this.myValue = myValue; 
    } 

    public String getMyValue() { 
     return myValue; 
    } 
} 

public static void main(String[] args) { 
    Map<String, String> propertyMap = new HashMap<>(); 
    propertyMap.put("key.in.map", "value.in.map"); 
    ApplicationContext ctx = ...; 
    // Do something??? 
    ctx.getBean(MyClass.class).getMyValue(); // Should return "value.in.map" 
} 

Answer 1

Wiosna zapewnia MapPropertySource które można zarejestrować (trzeba mieć ConfigurableEnvironment które dostarczają większość ApplicationContext implementacje twoi ApplicationContext „s Environment).

Te zarejestrowane wartości PropertySource są używane przez przeliczniki (w kolejności) do znalezienia wartości dla nazw zastępczych.

Oto pełna przykład:

@Configuration 
@ComponentScan 
public class Example { 

    @Bean 
    public static PropertySourcesPlaceholderConfigurer configurer() { 
     PropertySourcesPlaceholderConfigurer configurer = new PropertySourcesPlaceholderConfigurer(); 
     // can also add it here 
     //configurer.setPropertySources(propertySources); 
     return configurer; 
    } 

    public static void main(String[] args) { 
     Map<String, Object> propertyMap = new HashMap<>(); 
     propertyMap.put("key.in.map", "value.in.map"); 
     AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(); 
     MapPropertySource propertySource = new MapPropertySource("map-source", propertyMap); 
     ctx.getEnvironment().getPropertySources().addLast(propertySource); 
     ctx.register(Example.class); 
     ctx.refresh(); 

     MyClass instance = ctx.getBean(MyClass.class); 
     System.out.println(instance.getMyValue()); 
    } 
} 

@Component 
class MyClass { 
    private String myValue; 
    @Autowired 
    public MyClass(@Value("${key.in.map}") String myValue) { 
     this.myValue = myValue; 
    } 
    public String getMyValue() { 
     return myValue; 
    } 
} 

Answer 2

Udało mi się osiągnąć podobną funkcjonalność, chociaż może nie to, czego szukasz.

Oto mój kod:

application.properties

key.in.map=value.in.map 

beans.xml

http://www.springframework.org/schema/ partia http://www.springframework.org/schema/batch/spring-batch-2.1.xsd http://www.springframework.org/schema/jdbchttp://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.0.xsd „>

<context:component-scan base-package="com.chatar" /> 
</beans:beans> 

Config.java

package com.chatar.batch; 

import org.springframework.beans.factory.config.PropertiesFactoryBean; 
import org.springframework.context.annotation.Bean; 
import org.springframework.context.annotation.Configuration; 
import org.springframework.core.io.ClassPathResource; 

@Configuration 
public class Config { 

    @Bean(name = "mapper") 
    public PropertiesFactoryBean mapper() { 
     PropertiesFactoryBean bean = new PropertiesFactoryBean(); 
     bean.setLocation(new ClassPathResource("META-INF/spring/application.properties")); 
     return bean; 
    } 
} 

MyClazz.java

package com.chatar.batch; 

import java.util.Map; 

import org.springframework.beans.factory.annotation.Value; 
import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext; 
import org.springframework.stereotype.Component; 

@Component 
public class MyClazz { 
    @Value("#{mapper}") 
    private Map<String, String> props; 

    public Map<String, String> getProps() { 
     return props; 
    } 

    public static void main(String[] args) { 
     ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); 

     System.out.println("Value:: " + context.getBean(MyClazz.class).getProps().get("key.in.map")); // Should return 
    } 
} 

wyjściowa: Wartość :: value.in.map

Answer 3

Oto rozwiązanie I skończyło się. Konwertuję mapę na plik właściwości.

Map<String, String> propertyMap = ...; 
Properties properties = new Properties(); 
properties.putAll(propertyMap); 

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(); 
ConfigurableBeanFactory beanFactory = ctx.getBeanFactory(); 
PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer = new PropertySourcesPlaceholderConfigurer(); 
propertySourcesPlaceholderConfigurer.setProperties(properties); 
beanFactory.registerSingleton(PropertySourcesPlaceholderConfigurer.class.getSimpleName(), 
        propertySourcesPlaceholderConfigurer);