Mecanismos de proxy

public class SimplePojo implements Pojo {
    public void foo() {
        // la siguiente llamada al método es una llamada directa a la
        referencia "this"  this.bar();
    } public void bar() {
        // un poco de lógica...
    }
}

class SimplePojo : Pojo {
    fun foo() {
        // la siguiente llamada al método es una llamada directa a la referencia "this"
        this.bar()
    }
    fun bar() {
        // un poco de lógica...
    }
}

Si llama a un método en una referencia de objeto, entonces el método se llama directamente en esa referencia de objeto, como se muestra en la siguiente imagen y listado:

public class Main {
    public static void main(String[] args) {
        Pojo pojo = new SimplePojo();
        // esta es una llamada directa al método por referencia "pojo
        pojo.foo();
    }
}}

fun main() {
    val pojo = SimplePojo()
    // este es un directo llamada al método por referencia "pojo"
    pojo.foo()
}

La situación cambia un poco si la referencia contenida en el código del cliente es un proxy. Considere el siguiente diagrama y fragmento de código:

public class Main {
    public static void main(String[] args) {
        ProxyFactory factory = new ProxyFactory(new SimplePojo());
        factory.addInterface(Pojo.class);
        factory.addAdvice(new RetryAdvice());
        Pojo pojo = (Pojo) factory.getProxy();
        // ¡Esta es una llamada al método para el proxy!
        pojo.foo();
    }
}

fun main() {
    val factory = ProxyFactory(SimplePojo())
    factory.addInterface (Pojo::class.java)
    factory.addAdvice(RetryAdvice())
    val pojo = factory.proxy as Pojo
    // ¡esta es una llamada al método para el proxy!
    pojo.foo()
}

Lo más importante que hay que entender aquí es que el código del cliente está dentro de main(..) El método de la clase Main contiene un enlace al proxy. Esto significa que las llamadas a métodos en esta referencia de objeto son llamadas de proxy. Como resultado, el proxy puede delegar todos los interceptores (consejos) que sean relevantes para esa llamada a método en particular. Sin embargo, una vez que la llamada llega al objeto de destino (en este caso el enlace SimplePojo), todas las llamadas a métodos que puede realizar sobre sí mismo, como this.bar() o this.foo() se llamará en la referencia this, no en el proxy. Esto tiene consecuencias importantes. Esto significa que la llamada en sí no provocará que se ejecute el consejo asociado con la llamada al método.

Está bien, pero ¿qué puedes hacer al respecto? El mejor enfoque (el término "mejor" se usa libremente aquí) es refactorizar su código para que no se produzca la llamada en sí. Esto requiere algo de esfuerzo de su parte, pero es el mejor método y el menos invasivo. El siguiente enfoque es absolutamente terrible y no estamos seguros de que valga la pena centrarse en él precisamente porque es terrible. Puedes (por más doloroso que nos parezca) vincular completamente la lógica dentro de tu clase a Spring AOP, como se muestra en el siguiente ejemplo:

public class SimplePojo implements Pojo {
    public void foo() {
        // funciona, pero... ¡uf!
        ((Pojo) AopContext.currentProxy()).bar();
    } public void bar() {
        // un poco de lógica...
    }
}

class SimplePojo : Pojo {
    fun foo() {
         // funciona, pero... ¡uf!
        (AopContext.currentProxy() as Pojo).bar()
    } fun bar() {
            // un poco de lógica...
    }
}

Este enfoque Esto vinculará completamente su código a Spring AOP, y la clase misma sabrá que se está utilizando en un contexto AOP, lo que va en contra de AOP. También requerirá alguna configuración adicional al crear el proxy, como se muestra en el siguiente ejemplo:

public class Main {
    public static void main(String[] args) {
        ProxyFactory factory = new ProxyFactory(new SimplePojo());
        factory.addInterface(Pojo.class);
        factory.addAdvice(new RetryAdvice());
        factory.setExposeProxy(true);
        Pojo pojo = (Pojo) factory.getProxy();
        // ¡Esta es una llamada al método para el proxy!
        pojo.foo();
    }
}

fun main() {
    val factory = ProxyFactory(SimplePojo())
    factory.addInterface (Pojo::class.java)
    factory.addAdvice(RetryAdvice())
    factory.isExposeProxy = true
    val pojo = factory.proxy as Pojo
    // ¡esta es una llamada al método para el proxy!
    pojo.foo()
}

Finalmente, cabe señalar que AspectJ no tiene este problema de autollamada porque no es un AOP basado en proxy. framework.

Creación programática de proxies @AspectJ

Además de declarar aspectos en la configuración usando <aop:config> o <aop:aspectj-autoproxy>, también puede crear proxies mediante programación que proporcionen consejos a los objetivos. En esta parte, queremos centrarnos en la capacidad de crear servidores proxy automáticamente usando aspectos @AspectJ.

Puedes usar la clase org.springframework.aop.aspectj.annotation.AspectJProxyFactory para crear servidores proxy para el objeto de destino que ha sido recomendado por uno o más @AspectJ. El uso básico de esta clase es extremadamente simple, como se muestra en el siguiente ejemplo:

// crea una fábrica que puede generar un proxy para un objetivo determinado Fábrica de
AspectJProxyFactory factory = new AspectJProxyFactory(targetObject);
// agrega un aspecto, la clase debe ser un aspecto @AspectJ
// puedes llamarlo tantas veces como sea necesario con diferentes aspectos
factory.addAspect(SecurityManager.class);
// también se pueden agregar instancias de aspectos existentes, el tipo de objeto proporcionado debe ser un aspecto @AspectJ
factory.addAspect(usageTracker);
// ahora obtenemos el objeto proxy...
MyInterfaceType proxy = factory.getProxy();

// crear una fábrica que pueda generar proxies para dado el objeto de destino
val factory = AspectJProxyFactory(targetObject)
// agrega un aspecto, la clase debe ser un aspecto @AspectJ
// puedes llamarlo tantas veces como quieras con diferentes aspectos
factory.addAspect(SecurityManager::class.java)
// también puedes agregar instancias de aspecto existentes, el tipo de objeto proporcionado debe ser un aspecto @AspectJ
factory.addAspect(usageTracker)
// ahora obtén el objeto proxy...
val proxy = factory.getProxy<Any>()