Définir des propriétés pour un Printemps contexte

Je suis en utilisant le Printemps pour gérer les appels RMI à une certaine distance du serveur. Il est simple de construire un contexte d'application et d'obtenir les haricots à distance pour les appels à partir du client:

ApplicationContext context = new ApplicationContext("classpath:context.xml");

MyService myService = (MyService ) context.getBean( "myService " );

Cependant je ne vois pas de solution simple pour passer des propriétés dans la configuration. Par exemple si je veux déterminer le nom d'hôte pour le serveur distant lors de l'exécution du client.

J'avais idéalement avoir une entrée dans le Printemps contexte comme celui-ci:

<bean id="myService" class="org.springframework.remoting.rmi.RmiProxyFactoryBean">
  <property name="serviceUrl" value="rmi://${webServer.host}:80/MyService"/>
  <property name="serviceInterface" value="com.foo.MyService"/>
</bean>

et de transmettre les propriétés du contexte du client en tant que paramètre.

Je peux utiliser un PropertyPlaceholderConfigurer dans le contexte de remplacer ces propriétés, mais aussi loin que je peux dire que cela ne fonctionne que pour les propriétés en lecture à partir d'un fichier.

J'ai une application qui répond à ce (ajouté comme une réponse) mais je suis à la recherche d'un standard de Printemps de mise en œuvre pour éviter de rouler mon propre. Est-il une autre Printemps configurer (ou autre chose) pour aider à initialiser la configuration ou suis-je mieux de regarder java config pour y parvenir?

Où voulez-vous stocker vos propriétés?
le client peut se connecter à n'importe quel serveur, par exemple, l'utilisateur peut taper le nom d'hôte dans un champ de texte. Donc, il n'est pas déterminée au moment de la compilation.

OriginalL'auteur Rich Seller | 2009-07-06

1

Mise à jour:

Basé sur la question de mise à jour, ma suggestion est:
1. Créer un ServiceResolver bean qui gère ce dont vous avez besoin pour gérer en fonction de la rétroaction des clients;
2. Déclarer ce bean comme une dépendance aux services pertinents;
3. Au moment de l'exécution, vous pouvez mettre à jour /l'utilisation de ce haricot cependant vous voyez l'ajustement.
La ServiceResolver peut alors, soit sur le init-method ou à chaque invocation de déterminer les valeurs à retourner au client, basé sur, par exemple, JNDI recherches ou de l'environnement de variables.

Mais avant de faire cela, vous voudrez peut-être jeter un oeil à la options de configuration disponibles. Vous pouvez soit:
- ajouter des fichiers de propriétés qui n'ont pas à être présent au moment de la compilation;
- rechercher des valeurs de JNDI;
- obtenir des valeurs du Système.les propriétés.
Si vous avez besoin pour la recherche de propriétés à partir d'un emplacement personnalisé, jetez un oeil à org.springframework.beans.factory.config.BeanFactoryPostProcessor et comment le org.springframework.beans.factory.config.PropertyPlaceholderConfigurer est mis en œuvre.

L'idée de base est que vous obtenez les haricots avec la "brute" des propriétés, par exemple ${jdbcDriverClassName} et puis vous arrivez à les résoudre et de les remplacer par les valeurs souhaitées.

Merci c'est comment mon de mise en œuvre existantes t-il, je vais mettre à jour ma question pour refléter cela. J'espère qu'il y est une norme de Printemps de la mise en œuvre de ce si je peux éviter de rouler mon propre.

OriginalL'auteur Robert Munteanu

Voir http://forum.springsource.org/showthread.php?t=71815

TestClass.java

package com.spring.ioc;

public class TestClass {

    private String first;
    private String second;

    public String getFirst() {
        return first;
    }

    public void setFirst(String first) {
        this.first = first;
    }

    public String getSecond() {
        return second;
    }

    public void setSecond(String second) {
        this.second = second;
    }
}

SpringStart.java

package com.spring;

import java.util.Properties;

import com.spring.ioc.TestClass;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;

public class SpringStart {
    public static void main(String[] args) throws Exception {
    PropertyPlaceholderConfigurer configurer = new PropertyPlaceholderConfigurer();
    Properties properties = new Properties();
    properties.setProperty("first.prop", "first value");
    properties.setProperty("second.prop", "second value");
    configurer.setProperties(properties);

    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext();
    context.addBeanFactoryPostProcessor(configurer);

    context.setConfigLocation("spring-config.xml");
    context.refresh();

    TestClass testClass = (TestClass)context.getBean("testBean");
    System.out.println(testClass.getFirst());
    System.out.println(testClass.getSecond());
    }
}

spring-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <bean id="testBean" class="com.spring.ioc.TestClass">
        <property name="first" value="${first.prop}"/>
        <property name="second" value="${second.prop}"/>
    </bean>

</beans>

De sortie:

first value
second value

OriginalL'auteur Bert van Brakel

Ma solution existante implique la définition d'une nouvelle MapAwareApplicationContext qui prend une Carte supplémentaire en argument du constructeur.

public MapAwareApplicationContext(final URL[] configURLs,
    final String[] newConfigLocations,
    final Map<String, String> additionalProperties) {
    super(null);

    //standard constructor content here

    this.map = new HashMap<String, String>(additionalProperties);

    refresh();
}

Il remplace postProcessBeanFactory() pour ajouter dans un MapAwareProcessor:

protected void postProcessBeanFactory(
    final ConfigurableListableBeanFactory beanFactory) {
    beanFactory.addBeanPostProcessor(new MapAwareProcessor(this.map));
    beanFactory.ignoreDependencyInterface(MapAware.class);
}

La MapAwareProcessor implémente postProcessBeforeInitialization() qui permet d'introduire la carte dans n'importe quel type qui implémente l'MapAware interface:

public Object postProcessBeforeInitialization(final Object bean, 
        final String beanName) {
    if (this.map != null && bean instanceof MapAware) {
        ((MapAware) bean).setMap(this.map);
    }

    return bean;
}

Je puis ajouter une nouvelle fève de ma config pour déclarer une MapAwarePropertyPlaceholderConfigurer:

<bean id="propertyConfigurer"
  class="com.hsbc.r2ds.spring.MapAwarePropertyPlaceholderConfigurer"/>

Le configurer implémente MapAware, de sorte qu'il sera injecté avec la Carte comme ci-dessus. Il met ensuite en place resolvePlaceholder() pour régler les propriétés de la carte, ou de délégué du parent configurer:

protected String resolvePlaceholder(final String placeholder, 
        final Properties props, final int systemPropertiesMode) {
    String propVal = null;
    if (this.map != null) {
        propVal = this.map.get(placeholder);
    }
    if (propVal == null) {
        propVal = super.resolvePlaceholder(placeholder, props);
    }
    return propVal;
}

Bon dieu, c'est d'un compliqué solution à un problème simple...
C'est le genre de mon point de vue, il semble comme quelque chose qui devrait être réalisable sans trop d'effort, certainement moins d'effort que ce
Ou vous pourriez utiliser BeanFactoryPostProcessor: springindepth.com/book/...

OriginalL'auteur Rich Seller

1

PropertyPlaceholderConfigurer pouvez récupérer les propriétés d'un fichier, c'est vrai, mais si on peut pas les trouver, il tombe en arrière à l'aide des propriétés du système. Cela sonne comme une option viable pour votre application cliente, il suffit de passer le système de la propriété grâce à-D lorsque vous lancez le client.

De la javadoc

Un configurer vérifiera également contre
propriétés du système (par exemple, l'utilisateur".dir") si
il ne peut pas résoudre un espace réservé avec
une des propriétés spécifiées. Cette
peut être personnalisé via
"systemPropertiesMode".

OriginalL'auteur skaffman

Créer un RmiProxyFactoryBean instance et configurer le serviceUrl propriété directement dans votre code:

String serverHost = "www.example.com";

RmiProxyFactoryBean factory = new RmiProxyFactoryBean();
factory.setServiceUrl("rmi://" + serverHost + ":80/MyService");
factory.setServiceInterface(MyService.class);
try {
    factory.afterPropertiesSet();
} catch (Exception e) {
    throw new RuntimeException(
            "Problem initializing myService factory", e);
}
MyService myService = (MyService) factory.getObject();

OriginalL'auteur Chin Huang

Vous devez vous connecter pour publier un commentaire.