Jak mogę wprowadzić wartość właściwości do fasoli wiosennej, która została skonfigurowana za pomocą adnotacji?

Osobiście uwielbiam ten nowy sposób na wiosnę 3.0 z docs :

private @Value("${propertyName}") String propertyField;

Z właściwościami ładowanymi przez config:

<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"
      p:location="classpath:propertyFile.properties" name="propertiesBean"/>

Aby rozwinąć moją radość, mogę nawet kontrolować wyrażenie EL w IntelliJ i sprowadza mnie to do definicji własności!

Istnieje również całkowicie wersja non xml:

@PropertySource("classpath:propertyFile.properties")
public class AppConfig {

    @Bean
    public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
        return new PropertySourcesPlaceholderConfigurer();
    }

Jest nowa adnotacja @Value W Spring 3.0. 0M3. @Value obsługuje nie tylko #{...} wyrażenia, ale także ${...} placeholdery

<context:property-placeholder ... /> jest odpowiednikiem XML dla PropertyPlaceholderConfigurer.

Przykład: applicationkontekst.xml

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

Klasa komponentu

 private @Value("${propertyName}") String propertyField;

Inną alternatywą jest dodanie appProperties Bean pokazanych poniżej:

<bean id="propertyConfigurer"   
  class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="/WEB-INF/app.properties" />
</bean> 


<bean id="appProperties" 
          class="org.springframework.beans.factory.config.PropertiesFactoryBean">
        <property name="singleton" value="true"/>

        <property name="properties">
                <props>
                        <prop key="results.max">${results.max}</prop>
                </props>
        </property>
</bean>

Po pobraniu fasola może być rzucona na java.util.Properties, która będzie zawierać właściwość o nazwie results.max, której wartość jest odczytywana z app.properties. Ponownie, fasola ta może być iniekcją zależności (jako instancja Javy.util.Właściwości) do dowolnej klasy poprzez adnotację @ Resource.

Osobiście wolę to rozwiązanie (od drugiego, które zaproponowałem), ponieważ można dokładnie ograniczyć, które właściwości są narażone przez appProperties, a nie musisz przeczytać aplikację.właściwości dwa razy.

Muszę mieć dwa pliki właściwości, jeden dla produkcji i nadpisanie dla rozwoju (które nie zostaną wdrożone).

Aby mieć obie właściwości, które mogą być autowirowane oraz PropertyConfigurer, możesz napisać:

<bean id="appProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
    <property name="singleton" value="true" />

    <property name="ignoreResourceNotFound" value="true" />
    <property name="locations">
        <list>
            <value>classpath:live.properties</value>
            <value>classpath:development.properties</value>
        </list>
    </property>
</bean>

I odwoływać się do Właściwości Bean w PropertyConfigurer

<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="properties" ref="appProperties" />
</bean>

Zanim otrzymamy Spring 3-który pozwala na wprowadzanie stałych właściwości bezpośrednio do Twoich beans za pomocą adnotacji-napisałem podklasę PropertyPlaceholderConfigurer bean, która robi to samo. Możesz więc oznaczyć swoje ustawienia nieruchomości, a Wiosna automatycznie połączy je z fasolą w ten sposób:]}

@Property(key="property.key", defaultValue="default")
public void setProperty(String property) {
    this.property = property;
}

Adnotacja jest następująca:

@Retention(RetentionPolicy.RUNTIME) 
@Target({ElementType.METHOD, ElementType.FIELD})
public @interface Property {
    String key();
    String defaultValue() default "";
}

PropertyAnnotationAndPlaceholderconfigurer jest następujący:

public class PropertyAnnotationAndPlaceholderConfigurer extends PropertyPlaceholderConfigurer {

    private static Logger log = Logger.getLogger(PropertyAnnotationAndPlaceholderConfigurer.class);

    @Override
    protected void processProperties(ConfigurableListableBeanFactory beanFactory, Properties properties) throws BeansException {
        super.processProperties(beanFactory, properties);

        for (String name : beanFactory.getBeanDefinitionNames()) {
            MutablePropertyValues mpv = beanFactory.getBeanDefinition(name).getPropertyValues();
            Class clazz = beanFactory.getType(name);

            if(log.isDebugEnabled()) log.debug("Configuring properties for bean="+name+"["+clazz+"]");

            if(clazz != null) {
                for (PropertyDescriptor property : BeanUtils.getPropertyDescriptors(clazz)) {
                    Method setter = property.getWriteMethod();
                    Method getter = property.getReadMethod();
                    Property annotation = null;
                    if(setter != null && setter.isAnnotationPresent(Property.class)) {
                        annotation = setter.getAnnotation(Property.class);
                    } else if(setter != null && getter != null && getter.isAnnotationPresent(Property.class)) {
                        annotation = getter.getAnnotation(Property.class);
                    }
                    if(annotation != null) {
                        String value = resolvePlaceholder(annotation.key(), properties, SYSTEM_PROPERTIES_MODE_FALLBACK);
                        if(StringUtils.isEmpty(value)) {
                            value = annotation.defaultValue();
                        }
                        if(StringUtils.isEmpty(value)) {
                            throw new BeanConfigurationException("No such property=["+annotation.key()+"] found in properties.");
                        }
                        if(log.isDebugEnabled()) log.debug("setting property=["+clazz.getName()+"."+property.getName()+"] value=["+annotation.key()+"="+value+"]");
                        mpv.addPropertyValue(property.getName(), value);
                    }
                }

                for(Field field : clazz.getDeclaredFields()) {
                    if(log.isDebugEnabled()) log.debug("examining field=["+clazz.getName()+"."+field.getName()+"]");
                    if(field.isAnnotationPresent(Property.class)) {
                        Property annotation = field.getAnnotation(Property.class);
                        PropertyDescriptor property = BeanUtils.getPropertyDescriptor(clazz, field.getName());

                        if(property.getWriteMethod() == null) {
                            throw new BeanConfigurationException("setter for property=["+clazz.getName()+"."+field.getName()+"] not available.");
                        }

                        Object value = resolvePlaceholder(annotation.key(), properties, SYSTEM_PROPERTIES_MODE_FALLBACK);
                        if(value == null) {
                            value = annotation.defaultValue();
                        }
                        if(value == null) {
                            throw new BeanConfigurationException("No such property=["+annotation.key()+"] found in properties.");
                        }
                        if(log.isDebugEnabled()) log.debug("setting property=["+clazz.getName()+"."+field.getName()+"] value=["+annotation.key()+"="+value+"]");
                        mpv.addPropertyValue(property.getName(), value);
                    }
                }
            }
        }
    }

}

Zapraszam do modyfikacji do smak

Możesz też przypisać klasę:

@PropertySource("classpath:/com/myProject/config/properties/database.properties")

I mieć taką zmienną:

@Autowired
private Environment env;

Teraz możesz uzyskać dostęp do wszystkich swoich właściwości w ten sposób:

env.getProperty("database.connection.driver")

Spring way:
private @Value("${propertyName}") String propertyField;

Jest nowym sposobem wprowadzania wartości za pomocą klasy "PropertyPlaceholderConfigurer" Springa. Innym sposobem jest wywołanie

java.util.Properties props = System.getProperties().getProperty("propertyName");

Uwaga: Dla @Value, nie można używać static propertyField, powinno być tylko niestatyczne, w przeciwnym razie zwraca null. Aby to naprawić, dla pola statycznego tworzony jest niestatyczny setter, a nad tym seterem stosowana jest wartość@.

Możliwym rozwiązaniem jest zadeklarowanie drugiej fasoli, która odczytuje z tego samego pliku właściwości:

<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location" value="/WEB-INF/app.properties" />
</bean> 

<util:properties id="appProperties" location="classpath:/WEB-INF/app.properties"/>

Fasola o nazwie 'appProperties' jest typu java.util.Właściwości i mogą być zależne wstrzykiwane przy użyciu @Resource attruibute pokazanego powyżej.

Jeśli utknąłeś w Spring 2.5, możesz zdefiniować fasolę dla każdej z Twoich właściwości i wprowadzić je za pomocą kwalifikatorów. TAK:

  <bean id="someFile" class="java.io.File">
    <constructor-arg value="${someFile}"/>
  </bean>

I

@Service
public class Thing
      public Thing(@Qualifier("someFile") File someFile) {
...

Nie jest zbyt czytelny, ale wykonuje zadanie.

Jak wspomniano @Value robi to zadanie i jest dość elastyczny, ponieważ można w nim mieć spring EL.

Oto kilka przykładów, które mogą być pomocne:

//Build and array from comma separated parameters 
//Like currency.codes.list=10,11,12,13
@Value("#{'${currency.codes.list}'.split(',')}") 
private List<String> currencyTypes;

Inny, aby uzyskać set z list

//If you have a list of some objects like (List<BranchVO>) 
//and the BranchVO has areaCode,cityCode,...
//You can easily make a set or areaCodes as below
@Value("#{BranchList.![areaCode]}") 
private Set<String> areas;

Można również ustawić wartości dla typów prymitywnych.

@Value("${amount.limit}")
private int amountLimit;

Możesz wywołać metody statyczne:

@Value("#{T(foo.bar).isSecurityEnabled()}")
private boolean securityEnabled;

Możesz mieć logikę

@Value("#{T(foo.bar).isSecurityEnabled() ? '${security.logo.path}' : '${default.logo.path}'}")
private String logoPath;

Autowirowanie wartości nieruchomości do fasoli wiosennej:

Większość ludzi wie, że możesz użyć @Autowired, aby powiedzieć Spring, aby wstrzyknął jeden obiekt do drugiego, gdy ładuje kontekst aplikacji. Mniej znaną cechą informacji jest to, że można również użyć adnotacji @Value, aby wprowadzić wartości z pliku właściwości do atrybutów fasoli. zobacz ten post, aby uzyskać więcej informacji...

Nowe rzeczy na wiosnę 3.0 / / autowirowanie wartości fasoli / / autowirowanie nieruchomości wartości na wiosnę

Dla mnie to była odpowiedź @ Lucky, a konkretnie linia

AutowiredFakaSource fakeDataSource = ctx.getBean(AutowiredFakaSource.class);

From The Captain debug page

Jeśli potrzebujesz większej elastyczności konfiguracji, spróbuj Settings4jPlaceholderConfigurer: http://settings4j.sourceforge.net/currentrelease/configSpringPlaceholder.html

W naszej aplikacji używamy:

• Preferencje konfiguracji systemu PreProd i Prod
• preferencje i zmienne środowiskowe JNDI (JNDI nadpisuje preferencje) dla "mvn jetty: run"
• Właściwości systemu dla UnitTests (@BeforeClass adnotacja)

The domyślna kolejność, która klucz-wartość-źródło jest sprawdzana jako pierwsza, jest opisana w:
http://settings4j.sourceforge.net/currentrelease/configDefault.html
Można go dostosować za pomocą settings4j.xml (dokładne do log4j.xml) w swojej klasie.

Daj znać swoją opinię: [email protected]

Z przyjaznymi pozdrowieniami,
Harald

Myślę, że najwygodniejszym sposobem wstrzykiwania właściwości do fasoli jest metoda settera.

Przykład:

package org.some.beans;

public class MyBean {
    Long id;
    String name;

    public void setId(Long id) {
        this.id = id;
    }

    public Long getId() {
        return id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

Definicja xml Bean:

<bean id="Bean1" class="org.some.beans.MyBean">
    <property name="id" value="1"/>
    <property name="name" value="MyBean"/>
</bean>

Dla każdej podanej metody property zostanie wywołana metoda setProperty(value).

Ten sposób jest szczególnie pomocny, jeśli potrzebujesz więcej niż jednej fasoli opartej na jednej implementacji.

Na przykład, jeśli zdefiniujemy jeszcze jedną fasolę w xml:

<bean id="Bean2" class="org.some.beans.MyBean">
    <property name="id" value="2"/>
    <property name="name" value="EnotherBean"/>
</bean>

Następnie kod w ten sposób:

MyBean b1 = appContext.getBean("Bean1");
System.out.println("Bean id = " + b1.getId() + " name = " + b1.getName());
MyBean b2 = appContext.getBean("Bean2");
System.out.println("Bean id = " + b2.getId() + " name = " + b2.getName());

Wydrukuje

Bean id = 1 name = MyBean
Bean id = 2 name = AnotherBean

Więc w Twoim przypadku powinno wyglądać tak:

@Repository("personDao")
public class PersonDaoImpl extends AbstractDaoImpl implements PersonDao {

    Long maxResults;

    public void setMaxResults(Long maxResults) {
        this.maxResults = maxResults;
    }

    // Now use maxResults value in your code, it will be injected on Bean creation
    public void someMethod(Long results) {
        if (results < maxResults) {
            ...
        }
    }
}

Użyj klasy "PropertyPlaceholderConfigurer" Springa

Prosty przykład pokazujący Plik Właściwości odczytywany dynamicznie jako właściwość Beana

<bean id="placeholderConfig"
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="locations">
        <list>
            <value>/WEB-INF/classes/config_properties/dev/database.properties</value>
        </list>
    </property> 
</bean>

<bean id="devDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
    <property name="driverClass" value="${dev.app.jdbc.driver}"/>
    <property name="jdbcUrl" value="${dev.app.jdbc.url}"/>
    <property name="user" value="${dev.app.jdbc.username}"/>
    <property name="password" value="${dev.app.jdbc.password}"/>
    <property name="acquireIncrement" value="3"/>
    <property name="minPoolSize" value="5"/>
    <property name="maxPoolSize" value="10"/>
    <property name="maxStatementsPerConnection" value="11000"/>
    <property name="numHelperThreads" value="8"/>
    <property name="idleConnectionTestPeriod" value="300"/>
    <property name="preferredTestQuery" value="SELECT 0"/>
</bean> 

Plik Właściwości

Dev.app.jdbc.kierowca = com.mysql.jdbc.Kierowca

Dev.app.jdbc.url = JDBC: mysql: / / localhost: 3306 / addvertisement

Dev.app.jdbc.username=root

Dev.app.jdbc.password=root