Remplacer une fève à l'intérieur du printemps conteneur au cours de l'exécution

Suppose que je définir un bean (par exemple BeanA) à l'intérieur du Printemps conteneur, et ce bean est injecté dans un objet. (par exemple BeanAUser)

Au cours de l'exécution, puis-je utiliser un autre exemple d'haricot pour remplacer l'original BeanA à l'intérieur du printemps contenant???? Et aussi ré-injecte cette nouvelle instance de bean dans BeanAUser afin de remplacer l'original BeanA?

  • Je ne pense pas que cela est possible. Vous devriez probablement envisager d'autres solutions. Mais attendons de voir si soemone pouvez venir avec une solution.
  • Quelle est votre cas ? Mieux vaut savoir ce qui est contraignante pour ce faire.
InformationsquelleAutor Ken Chan | 2012-02-05
  1. 15

    Il peut être facilement réalisé à l'aide d'un proxy. Créer de la délégation de la mise en œuvre de votre interface et de l'objet de commutation, il est déléguant à la.

    @Component("BeanA")
public class MyClass implements MyInterface {
  private MyInterface target;

  public void setTarget(MyInterface target) {
    this.target = target;
  }

  //now delegating implementation of MyInterface methods
  public void method1(..) {
    this.target.method1(..);
  }

  ..
}
    • Bien que cela fonctionne, ne serait-ce pas la cause BeanA avoir trop de connaissances... qui, un peu défait le champ d'application de l'aide de DI en premier lieu. Je préfère créer une classe helper qui obtient injecté avec les différents types de haricots, et envelopper la logique qui décide de ce haricot exemple l'offre.
    • Je ne pense pas que je comprends. Les connaissances à propos de quoi? Cette classe est bête comme il est, c'est un proxy avec aucune logique. Il s'attend à une certaine classe externe pour faire du commutateur par le biais setTarget. La question n'a pas d'inclure des détails permettant à toute solution plus personnalisée.
    • J'ai mal compris votre démarche, depuis que vous l'avez nommé BeanA et compris le vous ajouter cette fonctionnalité à @KenChan de la mise en œuvre de BeanA... de même, le Printemps nous offre cette fonctionnalité à l'aide de l'arbitraire-méthode de remplacement, de sorte que si l'aide de Printemps, j'irais le Printemps-chemin de toute façon. En outre, elle permettrait d'éviter la nécessité d'avoir d'autres classes en cause et de garder tous les haricots de commutation logique en un seul endroit, tout en faisant tout cela de manière transparente à BeanAUser
    InformationsquelleAutor mrembisz
  2. 8

    Printemps a présenté le nouveau RefreshScope pour remplacer un haricot au moment de l'exécution. En interne, un proxy est créé, comme décrit dans le réponse de mrembisz.

    @RefreshScope
@Component
public class MyBean { ... }
    InformationsquelleAutor rwitzel
  3. 6

    La façon dont je voudrais le faire à l'aide d'un système appelé arbitraire de la méthode de remplacement.

    Créer une classe qui implémente org.springframework.beans.factory.support.MethodReplacer, cela va vous forcer à créer une méthode comme

    public Object reimplement(Object o, Method m, Object[] args) throws Throwable

    Les paramètres ont la signification suivante:

    • o - l'exemple d'haricot vous êtes le remplacement d'une méthode sur
    • m - la méthode de la méta nous sommes en remplacement de
    • args - les arguments de la méthode fourni (le cas échéant)

    Donc j'imagine que votre classe à ressembler à quelque chose comme ce qui suit

    public BeanAUserHelper implements MethodReplacer {

    public Object reimplement(Object o, Method m, Object[] args) throws Throwable {

        if (some expression){
            return beanA;
        }
        else {
            return beanB;
        }
    }
}

    Dans votre configuration spring, vous demandez Printemps pour remplacer la getBeanX() méthode sur votre BeanAUser comme

    <!-- this is the bean who needs to get a different instance -->
<bean id="beanAUser" class="a.b.c.BeanAUser">
    <!-- arbitrary method replacement -->
    <replaced-method name="getBeanX" replacer="beanAUserHelper"/>
</bean>

<!-- this is your 'dynamic bean getter' -->
<bean id="beanAUserHelper" class="a.b.c.BeanAUserHelper"/>

    J'espère que j'ai compris votre problème correctement 🙂

    • Je ne vois pas beaucoup de différence ici que dans le proxy. Ici, vous avez " si (une expression){' c'est le trop d'infos ... de retour de ce ou de haricots. Dans la procuration trop le travailleur haricots peuvent être injectés à partir du printemps et que la logique serait de déterminer à l'appel de la méthode sur le haricot a ou b
    • Comment ajouter replaced-method balise lors de la création de haricots à l'aide de l'Annotation @Bean
    InformationsquelleAutor Stefan Z Camilleri
  4. 4

    En supposant MyClass dans mrembisz la réponse n'est pas définitive, on n'a pas à mettre en oeuvre le décorateur modèle manuellement et on peut l'appliquer automatiquement à l'aide de BeanPostProcessor. Tout d'abord, définir l'extension de l'interface pour l'injection de nouvelles déléguer la mise en œuvre:

    public interface Wrapper extends MyInterface {
    void setTarget(MyInterface target);
}

    Puis créer BeanPostProcessor qui enveloppe toutes les implémentations de MyInterface à CGLIB proxy. Proxy sert à la fois de MyClass (qui lui permet d'être injecté dans les champs de MyClass type) et Wrapper (ce qui lui permet de changer de cible). Proxy redirige les originaux de toutes les invocations à MyClass cible (qui est initialement réglé sur la valeur déclarée au Printemps), l'invocation de Wrapper.setTarget résultats dans l'objectif de changement.

    @Component
public static class MyPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
Object result = bean;
if (bean instanceof MyInterface) {
final MyInterface myInterface = (MyInterface)bean;
Class<? extends MyInterface> clazz = myInterface.getClass();
if (!isFinal(clazz.getModifiers())) {
result = Enhancer.create(clazz, new Class[] {MyInterface.class}, new MethodInterceptor() {
private MyInterface target = myInterface;
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
if (method.getName().equals("setTarget") && method.getDeclaringClass().equals(Wrapper.class) && method.getParameterCount() == 1 && method.getParameterTypes()[0].equals(MyInterface.class)) {
this.target = (MyInterface)args[0];
return null;
} else {
Object result = proxy.invoke(this.target, args);
return result;
}
}
});
}
}
return result;
}
}

    Simplement l'idée est la suivante: définir le haricot au Printemps comme il était normal de haricot, de le modifier après l'initialisation.

    InformationsquelleAutor Tomáš Záluský
  5. 3

    Il existe des moyens pour manipuler printemps contexte avant qui l'a créé.

    1. Une certaine façon, vous utilisez GenericApplicationContext et GenericBeanDefinition classes pour manipuler contexte. Exemple de code suivant montre cette solution :

      GenericApplicationContext context = new GenericApplicationContext();
XmlBeanDefinitionReader xmlReader = new XmlBeanDefinitionReader(context);
xmlReader.loadBeanDefinitions(new ClassPathResource(original-context));
BeanDefinitionRegistry registry = ((BeanDefinitionRegistry) context);
GenericBeanDefinition myBean = new GenericBeanDefinition();
myBean.setBeanClass(MyCustomClass.class);
myBean.getPropertyValues().add("name", "My-Name");
registry.registerBeanDefinition("my_bean_name", myBean);
context.refresh();

    par cet extrait de code, vous pouvez ajouter, supprimer ou modifier les haricots avant de création.

    1. Deuxième solution est d'utiliser BeanPostProcessor mécanisme à ressort. Pour détaillées sont exposées voir cette url : http://www.roseindia.net/tutorial/spring/spring3/ioc/beanpostprocessor.html ou Pourquoi est-ce BeanPostProcessor nécessaires, en plus d'un UserDetailsService en ce Printemps 3.0 exemple d'authentification?
    InformationsquelleAutor Sam
  6. 0

    Vous êtes de passage d'une fine ligne ici. Fondamentalement, vous tentez de mettre de la logique de l'application au Printemps conteneur. Éviter de programmation avec vos fichiers de configuration et l'utilisation de Printemps (ou ce que DI-cadre) uniquement pour le câblage de base.

    Le proxy suggestion @mrembisz fait est donc préféré. De cette façon, la logique de l'application et de la configuration sont séparés.

    InformationsquelleAutor M Platvoet
  7. 0

    Une autre approche peut être l'utilisation Atomique de Référence de votre classe comme un Haricot au lieu d'utiliser la classe directement. Ensuite, vous pouvez injecter Atomique de Référence de n'importe où et de les mettre à jour. Tous les autres services d'utiliser la dernière version de votre classe après la mise à jour il atomique de référence. Et je pense que cela a du sens.

    Lire ce atomique de référence utilisation: https://stackoverflow.com/a/24765321/5197662

    Un inconvénient de cette approche est de perdre que le printemps ne peut pas traiter les annotations de votre classe. Par exemple, u ne peut pas utiliser @Cachable, @Async, @PreDestroy et les autres. Mais la solution est bonne, quand u juste besoin d'un objet et ses propriétés.

    InformationsquelleAutor Sep GH