Spring AOP pas de travail pour l'appel de méthode à l'intérieur d'une autre méthode

Il y a deux méthodes définies dans ABC.java

public void method1(){
   .........
   method2();
  ...........
}


public void method2(){
  ...............
  ...............  
}

Je veux avoir de l'AOP sur call of method2.Donc,
J'ai créé une classe,AOPLogger.java,ayant l'aspect de la fonctionnalité fournie dans une méthode checkAccess

Dans le fichier de configuration, j'ai fait quelque chose comme ci-dessous

<bean id="advice" class="p.AOPLogger" />
<aop:config>
  <aop:pointcut id="abc" expression="execution(*p.ABC.method2(..))" />
  <aop:aspect id="service" ref="advice">
    <aop:before pointcut-ref="abc" method="checkAccess" />          
  </aop:aspect>
</aop:config>

Mais quand mon method2 est appelé, AOP fonctionnalité n'est pas chargé, c'est à dire checkAccess méthode n'est pas chargé de AOPLogger classe.

Quelque chose que je suis absent?

InformationsquelleAutor Anand | 2012-11-26

59

L'aspect est appliqué à un proxy entourant le haricot. Notez que chaque fois que vous obtenez une référence à un haricot, ce n'est pas vraiment la classe référencée dans votre config, mais de façon synthétique les classe implémentant les interfaces pertinentes, en déléguant à la classe réelle et l'ajout de fonctionnalités, telles que votre AOP.

Dans votre exemple ci-dessus, vous appelez directement sur la classe, alors que si l'instance de classe est injecté dans l'autre, comme un Ressort de haricot, il est injecté comme son fondé de pouvoir, et donc les appels de méthode sera invoquée sur le proxy (et les aspects sera déclenchée)

Si vous voulez obtenir le ci-dessus, vous pouvez diviser method1/method2 dans distinct, des haricots, ou de l'utilisation d'un non-printemps-orienté AOP cadre.

La Printemps doc (section "fonctionnement de l'AOP Procurations") les détails, et un couple de solutions (y compris ma première suggestion ci-dessus)
- Désolé,je ne suis pas..pouvez-vous m'expliquer en termes simples, je suis de nouveau ou de fournir un bon lien
- Je pense que le Printemps doc lien qu'il contient beaucoup d'informations. Mais j'ai élargi un peu au-dessus
- Les aspects définis autour des méthodes de Printemps, les services ne fonctionnent pas et pensais que c'était dû à une mauvaise configuration. En fin de compte j'ai trouvé cette question et la réponse qui m'a sauvé plusieurs heures .. merci!
- Avez-vous une idée d'autres "Non-Printemps-Orienté AOP" cadre?
- utilisation AspectJ directement, soit au moment de la construction avec le compilateur AspectJ ou au moment de l'exécution avec les AspectJ au Moment du Chargement de la Tisserande.
- vous avez dit "l'ajout de fonctionnalités, telles que votre AOP". Ce que des fonctionnalités supplémentaires sont ajoutés en plus de l'AOP? Pouvez-vous svp donner quelques exemples
InformationsquelleAutor Brian Agnew
33

Il peut être fait par auto-injection d'utilisation. Vous pouvez appeler méthode interne par injecté exemple:
```
@Component
public class Foo {
    @Resource
    private Foo foo;

    public void method1(){
        ..
        foo.method2();
        ..
    }
    public void method2(){
        ..
    }
}
```
Depuis le Printemps 4.3 vous pouvez également le faire à l'aide de @Autocâblés.

Que de 4,3, @Autocâblés aussi l'estime de soi des références pour l'injection,
c'est à dire les références de retour à la fève qui est actuellement injectée.
- Oui, mais ce que sur les pauvres Foo#foo#foo ?
- C'est juste une solution de contournement. Je n'ai pas dit que c'est parfait, mais il fonctionne
InformationsquelleAutor Konstantin Zyubin
5

J'ai eu le même genre de problème et j'ai surmonté par la mise en œuvre du Printemps ApplicationContextAware,BeanNameAware et la mise en œuvre de méthodes correspondantes ci-dessous.
```
class ABC implements ApplicationContextAware,BeanNameAware{

      @Override
      public void setApplicationContext(ApplicationContext ac) throws BeansException {
          applicationContext=ac;
      }

      @Override
      public void setBeanName(String beanName) {
          this.beanName=beanName;
      }
      private ApplicationContext applicationContext;
      private String beanName;
}
```
puis j'ai remplacé this. avec ((ABC) applicationContext.getBean(beanName)). tout en appelant les méthodes de la même classe. Cela garantit que les appels aux méthodes de la même classe se produire à travers le proxy.

Donc method1() changements à
```
 public void method1(){
    .........
    ((ABC) applicationContext.getBean(beanName)).method2();
    ...........
  }
```
Espère que cette aide.
- Bien que cette méthode fonctionne certes, l'inconvénient est que votre classe est désormais étroitement couplé au framework spring. Si vous utilisez pur de configuration xml et pas d'annotations, de votre classe pourrait être indépendants sur le Printemps. Habituellement, la meilleure pratique est de revoir la logique pour être divisé en deux haricots. Toutefois, si l'accouplement à ressort n'est pas votre préoccupation, cette solution pourrait être assez bon.
InformationsquelleAutor pavan
3

Spring AOP cadre de "proxy" en fonction et c'est très bien expliqué ici:
http://static.springsource.org/spring/docs/3.1.x/spring-framework-reference/html/aop.html#aop-understanding-aop-proxies

Quand le Printemps construit un haricot qui est configuré avec un aspect (comme "ABC" dans votre exemple), il crée en fait un "proxy" de l'objet qui agit comme la vraie fève. Le proxy délègue simplement les appels à la "vraie" objet mais par la création de cette indirection, le mandataire obtient une chance de mettre en œuvre les "conseils". Par exemple, vos conseils pouvez enregistrer un message pour chaque appel de méthode. Dans ce schéma, si la méthode dans l'objet réel ("method1") appelle d'autres méthodes dans le même objet (par exemple, method2), ces appels se produire sans proxy dans l'image, donc il n'y a aucune chance pour elle de mettre en œuvre tous les conseils.

Dans votre exemple, quand method1() est appelée, le proxy va avoir une chance de faire ce que jamais il est censé faire, mais si method1() appelle method2(), il n'y a pas d'aspect de l'image. Comment jamais, si method2 est appelé à partir d'un autre bean, proxy sera en mesure de mener à bien les conseils.

Espère que cette aide.

Grâce,
Raghu

InformationsquelleAutor Raghuram
2

À l'aide de @Autowired il fonctionne.
Au lieu d'appeler la méthode intérieure comme this.method(), vous pouvez le faire:
```
@Autowired
Foo foo;
```
puis en appelant:
```
foo.method2();
```
- J'ai déjà répondu à un an avant
- mais il devrait en résulter une erreur d'exécution que vous vous retrouvez dans la dépendance circulaire
InformationsquelleAutor Rashmingadhvi
0

Il n'est pas possible ce que vous voulez atteindre. Une explication se trouve dans le Printemps De La Documentation De Référence.

InformationsquelleAutor Uwe Plonus
0

Comme indiqué dans le Printemps docs, chapitre 5.6.1 la Compréhension de l'AOP procurations, il est une autre façon que vous pouvez faire:
```
public class SimplePojo implements Pojo {

    public void foo() {
        //this works, but... gah!
        ((Pojo) AopContext.currentProxy()).bar();
    }

    public void bar() {
        //some logic...
    }
}
```
Bien que l'auteur n'a pas recommander cette façon. Parce que:

Ce totalement couples votre code de Spring AOP, et il fait la classe elle-même conscient du fait qu'il est utilisé dans une AOP contexte, qui vole dans le visage de l'AOP. Il nécessite une configuration supplémentaire lorsque le proxy est en cours de création.

InformationsquelleAutor Qianyue

Vous pouvez faire l'auto-injection de cette façon, de sorte que cette classe peut être utilisée à l'extérieur de Printemps de l'application.

@Component
public class ABC {

    @Resource
    private ABC self = this;

    public void method1() {
        self.method2();
    }

    public void method2() {

    }

}

InformationsquelleAutor Fai

0

Annoter des appels avec @EnableAspectJAutoProxy(exposeProxy = true) et d'appeler les méthodes d'instance avec ((Classe) AopContext.currentProxy()).méthode();

Ce n'est strictement pas recommandée, car elle augmente à l'accouplement

InformationsquelleAutor shiva kumar
0

Je suis étonné que personne n'a mentionné cela, mais je crois que nous pouvons utiliser ControlFlowPointcut fourni par Spring.

ControlFlowPointcut regarde stacktrace et les matches de la coupe transverse (pointcut) seulement s'il trouve une méthode particulière dans la stacktrace. essentiellement coupe transverse (pointcut) n'a d'égale que lorsqu'une méthode est appelée dans un contexte particulier.

Dans ce cas, nous pouvons créer une coupe transverse (pointcut) comme
```
ControlFlowPointcut cf = new ControlFlowPointcut(MyClass.class, "method1");
```
maintenant, à l'aide de ProxyFactory créer un proxy sur MyClass instance et d'appel method1().

Dans le cas ci-dessus, seulement method2() sera conseillé car il est appelé à partir de method1().

InformationsquelleAutor Arjun Patil

Vous devez vous connecter pour publier un commentaire.