loupi loupi wrote:

 

Question N=°1 how JBoss AOP defines an abstract aspect? and how it makes the reuse?(example in AspectJ we find Abstarct aspect)

 

JBoss AOP does not define an abstract aspect, you can however write an abstract class that will be the superclass of your aspect,  or define a common interface to more than one aspects in your system. The reason for this is that JBoss AOP, differently from AspectJ, is not an AOP language, it is an AOP tool. It will weave code that has been previously compiled with javac.

loupi loupi wrote:

 

Question N=°2 how can we access to variable with the mixin mechanism?because I followed your example

See the previous paragraph. As JBoss AOP is a Java tool, your code needs to compile first, using a plain Java compiler.

Still, what you want to do can be achieved. There is a very good example in our dist, in the examples dir. The introductions example contains the POJO2ExternalizableMixin, that acquires access to the class it is applied to, POJO2, in its constructor. You would have to do the same, i.e., FooMixin will receive Foo in its constructor, initialize a private field with foo, and use that to get access to fooMethod2 value:

public clas FooMixin implements FooInt {

     private Foo target;

     public FooMixin (Foo foo) {
          target = foo;
     }

     public String fooMethod2 (int i) {
          return Integer.toString (target.fooField - i); 
     }
}

Check out introductions example code to see the details (it is in the docs/aspect-framework/examples/introductions path of your JBoss AOP installation dir).

Can you explain better? Are you saying that you want to have something like a pointcut that checks the value of the variable of class1 before deciding if the mixin will apply to class 2?

If that's not what you are trying to say, maybe a piece of code (even if it doesn't compile with JBoss AOP) showing what you want to do would help a lot!

Anyway, what is the relationship of class1 and class2? We need someway of going from Class2 to Class1. It is ok if this requires using package protected methods and fields.

In order to do that, first of all you need to change the signature of update method to something like this:

package Bee ;
public interface FlowerObserver {    
      public void update(boolean isOpen);
}

Now, your implementation must also receive the isOpen value as a parameter and that way you can check on whether the flower is open before deciding to either call Bee.dinner() or Bee.rest().

Another thing that you have to workaround is how to call this. JBoss AOP needs to control the creation of aspects. AFAIK, this is not a limiting factor exclusive to JBoss AOP, all AOP languages/tools need to have some control of how to create the aspect. So, you can't have as an aspect an  object you created yourself (i.e, it can't be the bees you are creating in main).

To workaround that:

- keep the interface as above

- add an Observable interface and a Mixin for that:

public interface Observable {
    public void addObserver(FlowerObserver observer);
    public void notifyAll();
}

public ObservableMixin {
    private Collection<FlowerObserver> observers = ...;
    private final Flower flower;
    public ObservableMixin(Flower flower) { this.flower = flower}
    public void addObserver(FlowerObserver observer) { observers.ad(observer);}
    public void notifyAll() { for(FlowerObserver: observers) { observer.update(flower.isOpen());}}
}

- and finally an after aspect that triggers the notification (use just the same xml you used, but replace BeeObserver update() by the ObserverAspect updateObservers advice below):

public class ObserverAspect() {
      public void updateObservers(@Target Observable observable) { observable.notifyAll(); }
}

- don't forget to add the ObservableMixin above to Flower class!

Now, in main, you can make:

((Observable) flower).addObserver((FlowerObserver) bee1);
((Observable) flower).addObserver((FlowerObserver) bee2);

And that's it!