1. Que es AOP
AOP es la abreviatura de la programación orientada a los aspectos, lo que significa programación orientada a los aspectos. AOP es en realidad una continuación del modelo de diseño GOF.
2. Algunos términos sobre la primavera AOP:
A. Aspecto: en Spring AOP, la faceta se puede implementar utilizando una clase general o en una clase normal con anotación @Spect (estilo @Aspectj)
B. Punto de unión: en Spring AOP, un punto de conexión representa la ejecución de un método.
C. Consejo: una acción realizada en un punto conjunto específico en la sección. Hay varios tipos de notificaciones, que incluyen "alrededor", "antes" y "después". Muchos marcos de AEOP, incluidos Spring, usan interceptores como modelos de notificación y mantienen una cadena de interceptores centrada en el punto de enlace.
D. Pointcut: defina uno o un grupo de métodos, que pueden generar notificaciones al ejecutar estos métodos. Spring utiliza la sintaxis de corte de punto SuppeJ de forma predeterminada.
3. Tipo de notificación
A. pre-notificación (@before): una notificación ejecutada antes de un punto de unión, pero esta notificación no puede evitar la ejecución antes del punto de conexión (a menos que arroje una excepción)
B. Notificación después de la devolución (@AfterReturning): la notificación ejecutada después de un punto de conexión (punto de unión) se completa normalmente: por ejemplo, un método no arroja ninguna excepción y regresa normalmente
C. Notificación después de que se lanza la excepción (@Afterthrowing): notificación ejecutada cuando el método arroja la excepción y sale
D. Post Notificación (@After): notificación ejecutada cuando sale un punto de conexión (ya sea un retorno normal o una salida anormal)
E. Notificación envolvente (@around): notificaciones que rodean un punto de unión, como las llamadas de método. Este es el tipo de notificación más potente, y las notificaciones envolventes pueden completar el comportamiento personalizado antes y después de las llamadas del método. También elige si continuar ejecutando los puntos de conexión o devolver directamente su propio valor de retorno o lanzar una excepción para finalizar la ejecución
4. @Aspectj Style AOP Configuración
La configuración de Spring AOP tiene dos estilos:
A. XML Style = Implementar Spring AOP en forma declarativa
B. spectJ style = implementar la primavera AOP utilizando el formulario de anotación
5. Ejemplo
Apeto
paquete com.spring.aop; / *** Sección*/ public class testAspect {public void doafter (unkenpoint jp) {system.out.println ("Método de finalización de registro:" + jp.getTarget (). GetClass (). GetName () + "." + Jp.getSignature (). GetName ()); } Public Object Doaround (procedimientojoinpoint pjp) lanza lando {larga tiempo = system.currentTimemillis (); Objeto retval = pjp.proced (); Time = System.CurrentTimemillis () - Tiempo; System.out.println ("Tiempo de proceso:" + Time + "MS"); return Retval; } public void doBefore (unkepoint jp) {System.out.println ("Log Burnining Method:" + JP.GetTarget (). GetClass (). GetName () + "." + JP.GetSignature (). GetName ()); } public void dothrowing (JoinPoint JP, Throwable Ex) {System.out.println ("Método" + JP.GetTarget (). GetClass (). GetName () + "." + JP.GetSignature (). GetName () + "Excepción de lanzamiento"); System.out.println (ex.getMessage ()); } private void sendex (String ex) {// toDo Enviar sms o recordatorio de correo electrónico}} paquete com.spring.service; / ** * Interfaz A */ Public Interface AService {public void fooa (string _msg); público vacío Bara (); } paquete com.spring.service; / ***Clase de implementación de interfaz A*/ public class AServiceImpl implementa AService {public void Bara () {System.out.println ("AServiceImpl.Bara ()"); } public void fooa (String _msg) {System.out.println ("AserviceImpl.fooa (msg:"+_ msg+")"); }} paquete com.spring.service; / ** * Clase de servicio B */ clase pública BServiceImpl {public void Barb (String _msg, int _type) {System.out.println ("bserviceImpl.Barb (msg:"+_ msg+"tipo:"+_ tipo+")"); if (_type == 1) tirar nueva ilegalargumentException ("excepción de prueba"); } public void foob () {System.out.println ("bserviceImpl.foob ()"); }}ApplicationContext
<? xml versión = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" "" "" xmlns: aop = "http://www.springframework.org/schema/aop" xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/scoans/spring-beat-beanspreing-BeAns http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd "default-auTowire =" autodetect "> <aop> <aop: aspecto id =" testaspect "ref =" aspecto "> <! clases o interfaces en com.spring.service paquete-> <aop: pointCut id = "BusinessService" Expression = "Execution (*com.spring.service.*.*(..))"/> <aop: antes de PointCut-REf = "BusinessService" Method = "DoBeFore"/> <aop: After PointCut -Rf = "BusinessService" <AOP: Around PointCut-REF = "BusinessService" Method = "Doaround"/> <aop: después de la tracción de punto-ref = "BusinessService" Method = "Dothrowing"/> </aop: Aspecto> </aop: config> <bean id = "AspectBean"/> <bean id = "aservice"> </beans> </beans>>
Prueba de clase Aoptest
Public Class Aoptest extiende Abstract DePendencyInjectionsPringContextTests {private aservice aservice; bserviceImpl privado privado; String protegido [] getConfigLocations () {String [] configs = new String [] {"/ApplicationContext.xml"}; devolver las configuraciones; } / *** Test Call Normal* / public void testCall () {System.out.println ("SpringTest Junit Test"); aservice.fooa ("Junit Test fooa"); aservice.bara (); bservice.foob (); BService.Barb ("Junit Test Barb", 0); } / ** * Test después de lanzar * / public void testThrow () {try {bService.Barb ("Junit Call Barb", 1); } Catch (ilegalArgumentException e) {}} public void setAservice (servicio aservice) {aservice = servicio; } public void setBService (servicio BServiceImpl) {bservice = servicio; }}
Los resultados de la operación son los siguientes:
Método de inicio de registro: com.spring.service.aserviceImpl.fooa aserviceImpl.fooa (msg: Junit test fooa) Método de finalización de log: com.spring.service.aserviceImpl.fooa Tiempo de proceso: 0 MS Log Method: Com.spring.service.aserviceImpl.Bara AServiceImpl.Bara (Log de log Method: com.spring.service.aserviceImpl.Bara AServiceImpl.Barae (Log inicio de log com.spring.service.aserviceImpl.Bara Tiempo de proceso: 0 MS LOG Método de inicio: com.spring.service.bserviceImpl.foob bserviceImpl.foob () Método de finalización de registro: com.spring.service.bserviceImpl.foob Tiempo de proceso: 0 MS de MS Comienzo Método: com.spring.service.service.Service.BserviceMarppl.BarbarbarbarBarbarBarBarBarBarBarBarBarBarBarbil. BServiceImpl.Barb (Msg: Junit Test Barb Tipo: 0) Método de finalización de registro: com.spring.service.bserviceImpl.Barb Tiempo de proceso: 0 MS MS Comenzando el método: com.spring.service.bserviceImpl.Barb BServiceImiM.Barb (Msg: Msg: Junit Call Type: 1) Método de log en final: com.spring.service.bserviceImpl.Barb Method com.spring.service.bserviceImpl.Barb Trow Exception Exception