Description Carlos Pita 2008-01-12 11:28:44 EST

Instead what is adviced is the introduced object (maybe a delegate?). Take for example the following aspect, which is intended to after advice deserialization of objects annotated with @Injected. For this, the aspect introduces the method DeserializationSupport.readResolve() and makes the adviced class implements Serializable. readResolve() is part of the deserialization protocol, and will be invoked by the java rt during deserialization if it's there. 

@Aspect
public class InjectorAspect {

    @After("execution(* framework.injection.InjectorAspect.DeserializationSupport.readResolve()) && this(injected)")
    public void afterDeserialization(Object injected, JoinPoint jp) {
       // I get a DeserializationSupportImpl instance here :(
    }
    
    @DeclareParents(value="@framework.injection.Injected java.io.Serializable+", defaultImpl=DeserializationSupportImpl.class)
    private DeserializationSupport deserializationSupport;
    
    public interface DeserializationSupport extends Serializable {
        public Object readResolve() throws ObjectStreamException;
    }
    
    @SuppressWarnings("serial")
    public static class DeserializationSupportImpl implements DeserializationSupport {
        public Object readResolve() throws ObjectStreamException {
            return this;
        }
    }
}

What are really being intercepted are instances looking like framework.injection.InjectorAspect$DeserializationSupportImpl@b16f5f. These are not instances of the expected @Injected at all! Even if I relaxed to advice pointcut to: "execution(* *.readResolve()) && this(injected)", the only intercepted instances would still be DeserializationSupportImpl ones, never @Injected objects.

But then, rewriting the aspect in aj-style, makes it work as pretended

public aspect InjectorAspect {

    after(Object injected) :
        execution(Object DeserializationSupport+.readResolve() throws ObjectStreamException) && @this(Injected) && this(injected) {
       // I get an @Intected instance here :) !
    }
    
    declare parents: @Injected Serializable+ implements DeserializationSupport;

    interface DeserializationSupport extends Serializable {
    }

    public Object DeserializationSupport.readResolve() throws ObjectStreamException {
        return this;
    }
}

AFAICS the only difference in the second version is the extra pointcut clause "@this(Injected)". But of course if I add this clause to the annotation-style version, no joinpoint will be matched, because even the much more permisive "execution(* *.readResolve())" never makes true "@this(Injected)".

I think this is a bug because it implies there are different semantics for things that -at least from my interpretation of the docs- should be equivalent. Also, a valid use case (advicing introduced method) seems to be outside the scope of annotation-style aspects.