ApplicationContext.getBean(Classe clazz) ne va pas bien avec les procurations

J'ai un haricot définition au Printemps et c'est le proxy de contrepartie, qui est destinée à être utilisée partout:

<bean name="my.Bean" class="org.springframework.aop.framework.ProxyFactoryBean" scope="prototype">
  <property name="proxyInterfaces" value="my.Interface"/>
  <property name="target" ref="my.BeanTarget"/>
  <property name="interceptorNames">
    <list>
      <value>someInterceptor</value>
    </list>
  </property>
</bean>

<bean name="my.BeanTarget" class="my.InterfaceImpl" scope="prototype">
  <property name="foo" ref="bar"/>
</bean>

Tout cela fonctionne bien; et en pré-Printemps v3 monde j'ai été en utilisant comme

ApplicationContext ctx = ...;
my.Interface foo = (my.Interface) ctx.getBean("my.Bean"); //cast is necessary

Au Printemps 3 il est devenu possible de faire de ce type de coffre-fort des recherches, par exemple:

my.Interface foo = ctx.getBean(my.Interface.class);

Encore une fois, cela fonctionne bien pour les haricots, tandis que pour proxy haricots je suis my.BeanTarget au lieu de my.Bean. J'ai essayé de l'inclure my.BeanTarget (comme indiqué dans le Ressort de la documentation) pour le rendre cachés, mais je n'ai eu

org.springframework.beans.factory.NoSuchBeanDefinitionException: No unique bean of type [my.Interface] is defined: expected single bean but found 0:

Ainsi est-il possible d'utiliser le type sûr de haricots recherches avec proxy haricots et si oui comment faire?

Avez-vous vraiment besoin d'interagir avec le contexte directement? La plupart de mes applications n'ont besoin que de bootstrap et puis tout le reste est géré avec l'injection de dépendance (qui travaille pour le proxy haricots). Je me suis fait un certain cadre des trucs où je n'ai besoin d'accéder au contexte, mais, dans mon expérience, il était rare.
Notre système est assez large et quelques morceaux, et les classes ne sont pas nés au Printemps (ni peut-être), de sorte qu'ils ont à utiliser beanFactory/appCtx pour obtenir des dépendances nécessaires.

OriginalL'auteur mindas | 2010-08-26

6

Le problème ici, c'est la scope="prototype" sur votre ProxyFactoryBean.

Le contexte n'aura très initialiser singleton bean définitions. Les haricots de non-portée singleton ne sont initialisés lors de la demande. Cela signifie que lorsque vous demandez le contexte pour les haricots d'un type donné, le contexte ne peut pas initialiser ces non-singleton haricots afin de leur demander leur type, il doit aller uniquement sur les informations contenues dans la fève de définition.

Dans le cas de ProxyFactoryBean, le type de proxy généré est déterminé par une logique complexe qui nécessite de la fève à être entièrement initialisé. Sans que l'initialisation, ProxyFactoryBean peut seulement indiquer le type de cible que null.

Je ne peux pas dire un moyen de contourner cela, d'autres que l'utilisation d'un singleton bean définition, ou explicitement demandé pour le haricot par nom, par ex.
```
<bean id="my.Interface"> class="ProxyFactoryBean"... >
```
et puis:
```
ctx.getBean(MyInterface.class.getName());
```
Ici, nous utilisons la convention de haricots noms étant l'interface ils mettent en œuvre.

OriginalL'auteur skaffman
2

Il ressemble à la portée de procurations créé par ProxyFactoryBean doit être spécifié à l'aide de singleton de la propriété au lieu de scope attribut:
```
<bean name="my.Bean" class="org.springframework.aop.framework.ProxyFactoryBean">  
    <property name="singleton" value="false"/>  
    ...
</bean>
```
Cela a résolu le problème lors de la cible, la fève est intérieure.

Lorsque vous avez plusieurs haut-niveau en grains de la même classe, vous pouvez utiliser un type-safe de recherche par id:
```
my.Interface foo = ctx.getBean("my.Bean", my.Interface.class); 
```
J'ai accepté cette réponse trop rapidement. Il s'avère que singleton=false à la propriété n'est pas la même chose que le champ d'application=prototype. J'ai réussi à obtenir singleton, les haricots sont emballés dans la cible procurations même si singleton=false a été spécifié. skaffman la réponse est en fait plus proche de la vérité.
Qu'est-ce que l'argument de la chaîne dans ce getBean(String, Class)? Pouvez-vous expliquer?
C'est un nom de la demande d'un bean dans le contexte de l'application. Il correspond à id ou name attribut XML de configuration.

OriginalL'auteur axtavt
1

Ne pouvez pas vous rendre my.Interface foo = ctx.getBean(my.Bean.class); ?

OriginalL'auteur Bozho
0

Que les travaux du Printemps, avec des Interfaces, dans le cadre de l'aop, vous pouvez définir différents ensemble d'interfaces et de la demande de celui que vous attendez. De cette façon, pas de cast seront nécessaires pour une véritable classe mais le Printemps sera de gérer les interfaces.

Disons que vous avez Une Classe implémente B. Vous voulez jeter de A à B, mais il est refusé comme un proxy est en raison de l'aop.
Ensuite, faire Un implémente C et C s'étend B. C possède nécessaire des méthodes, et C est interface privée accessible uniquement à partir de votre mise en œuvre du code.
Enfin vous demander de printemps à injecter B ou C en fonction de vos attentes.
```
PrivateItf executor = context.getBean(PrivateItf.class);
```
De cette façon, même si la différence de classe est un proxy, il met en œuvre votre Interface Privée avec tout ce qu'il vous faut.

OriginalL'auteur Cyrille Cormier

Vous devez vous connecter pour publier un commentaire.