Primero pensé en usar ITD para definir el private static final Logger logger = ... para algunos casos no relacionados, pero no parece suficiente como una mejora obvia para usarlo como un ejemplo de demostración.¿Qué es un breve ejemplo de declaraciones inter-tipo en AspectJ que demuestra la utilidad del enfoque?
¿Hay algún ejemplo estándar/sugerido de uso de ITD, que las personas deberían usar con fines didácticos?
Me gustaría agregar otro ejemplo a la respuesta de Adam.
Usar aspectos es una forma de mejorar la modularización de su software, así como de OOP, excepto que OOP se aplica "verticalmente", mientras que AOP se aplica "horizontalmente".
Así que, si bien el consejo puede usarse para modificar "horizontalmente" el comportamiento de todos los métodos respondiendo a algunos criterios, un código adicional en el consejo necesitará también algunos datos, e ITD permite agregar esos campos "horizontalmente" mientras al mismo tiempo, contiene en una sola unidad de compilación (el aspecto) los datos y el código relacionados.
Dado que está agregando datos a través de campos ITD, probablemente también desee ofrecer algún método para manipular esos campos, como un setter/getter.
Intenté expresarlo varias veces, espero que sea fácil de entender.
Para darle un ejemplo, suponga que tiene un programa de edición gráfica, donde el usuario puede crear, eliminar y mostrar una cantidad de Formas (bastante canónico ¿eh?: D).
Las formas tienen una gran cantidad de datos, por ejemplo, tienen un color, coordenadas, etc. que pertenecen correctamente a la clase en sí. Sin embargo, dado que esta es una aplicación web 3.0, desea que los usuarios puedan cooperar en un solo dibujo, lo que significa que cada forma debe saber cuándo se cambia, si se ha comunicado a otros usuarios que la forma se ha cambiado, ya sea está bloqueado por algún usuario que realmente lo está arrastrando, etc.
Puede hacerlo en OOP simple, implementando partes relevantes en Shape o cualquiera que sea su clase raíz, pero contaminará a todos sus instaladores con llamadas como "this .setDirty (true) "o cosas similares.
En su lugar, decide ir a AOP e implementarlo en un aspecto. En este caso, puede agregar fácilmente un consejo después de todos los ajustadores, pero también necesitará almacenar un booleano "sucio" o incluso una lista de propiedades que cambiaron si desea optimizar su protocolo de red enviando solo deltas de cambios.
podría implementar como si fuera
public aspect ShapesAreDirtyThings {
private boolean Shape.dirty;
after(Shape s) : execution(* Shape+.set*(..)) {
s.dirty = true;
// Set some other global field, start a thread to communicate
// to other users about the change, whatever ..
}
public boolean Shape.isDirty() {
return s.dirty;
}
public boolean Shape.findDirtyChildren() { // whatever
}
Esto no es nada que no se puede ver con AOP común, es simplemente una cuestión de encapsular en una unidad de asesoramiento sola compilación, los datos necesarios para que los consejos y métodos que eventualmente operar en esos datos.
Java no admite herencia múltiple o mixin. Pero con ITD puedes hacer Scala like Traits o Ruby como Mixins.
Aquí se muestra un ejemplo de tomar ventaja de la APP y de la primavera configurable:
Interfaz:
package com.evocatus.aop;
public interface DomainNotify {
public void postPersist();
public void postUpdate();
public void postRemove();
}
AspectJ ITD:
package com.evocatus.aop;
import javax.persistence.PostPersist;
import javax.persistence.PostRemove;
import javax.persistence.PostUpdate;
import javax.persistence.Transient;
import org.codehaus.jackson.annotate.JsonIgnore;
import org.springframework.beans.factory.annotation.Autowired;
import com.evocatus.service.DomainNotifyService;
privileged aspect DomainNotifyAdvice {
@JsonIgnore
@Transient
@Autowired
transient DomainNotifyService DomainNotify.domainNotifyService;
@PostPersist
public void DomainNotify.postPersist() {
this.domainNotifyService.publishSave(this);
}
@PostUpdate
public void DomainNotify.postUpdate() {
this.domainNotifyService.publishUpdate(this);
}
@PostRemove
public void DomainNotify.postRemove() {
this.domainNotifyService.publishRemove(this);
}
}
Ahora, cualquier clase que implementa DomainNotify se obtener los métodos ITD tejidos.
@Entity
@Configurable
public class MyJPAObject implements DomainNotify {
}
Eche un vistazo a Spring ROO. Es un desarrollador rápido. env usando Spring. Lo veo como un Ruby on Rails pero en Java con Spring ;-)
Utiliza ITD mucho para generar getter, setter, toString, etc ... en función de los atributos que defines cuando creas tu clase.