Introducción
La programación orientada orientada (AOP) proporciona otra perspectiva para pensar sobre la estructura del programa, que compensa las deficiencias de la programación orientada a objetos (OOP). Además de las clases, AOP proporciona facetas. Modularizar el enfoque, como la gestión de transacciones transversales de múltiples tipos y objetos. (Estos términos de preocupación a menudo se denominan preocupaciones transversales).
Un componente clave de Spring es el marco AOP. A pesar de esto, los contenedores de Spring IOC no dependen de AOP, lo que significa que es libre de elegir si usar AOOP. AOP proporciona una potente solución de middleware, que hace que los contenedores de Spring IOC sean más completos.
Primavera 2.0 AOP:
Spring 2.0 presenta una forma más simple y poderosa de personalizar la sección, y los usuarios pueden optar por usar métodos basados en esquemas o usar anotaciones @Aspectj. Para nuevas aplicaciones, si el usuario se está desarrollando en Java 5, recomendamos que el usuario use el estilo @Aspectj, de lo contrario el estilo basado en patrones se puede usar. Ambos estilos admiten plenamente el tipo de asesoramiento y el lenguaje puntual de SuppeJ, aunque todavía se está tejiendo usando Spring AOP.
Este capítulo discute principalmente el soporte de Spring 2.0 para AOP basado en patrones y @SuppeJ. Spring 2.0 conserva completamente la compatibilidad hacia atrás de Spring 1.2. El próximo capítulo discutirá el soporte de AOP subyacente proporcionado por la API Spring 1.2.
AOP usado en primavera:
Se proporcionan servicios empresariales declarativos, especialmente en lugar de los servicios declarativos de EJB. El servicio más importante es la gestión de transacciones declarativas, que se basa en la abstracción de transacciones abstractas de Spring.
Permite a los usuarios implementar secciones personalizadas y usar AOP para mejorar el uso de OOP.
Ejemplo
A menudo usamos los siguientes tipos
1. AOP basado en el agente
2. Facetas de objetos Java puros y simples
3. @Spect Annotation Form
4. Aplicemos las secciones ASPCET en la forma de inyección una por una.
Primero escribamos algunas clases básicas.
Clase de interfaz:
/ *** Defina una interfaz*/ interfaz pública durmiente {/ *** método para dormir*/ void sleep (); } Clase de implementación:
/ *** Implemento la interfaz de sueño*/ public class Chenllina implementa durmible {@Override public void sleep () {// toDo Method generado automático stub System.out.println ("¡Sea bueno, es hora de ir a la cama!"); }} Clase de mejora:
/ *** Defina una mejora del sueño para lograr el método de implementos de SleepHelper de clase previa y postset*/ PublicSper, después de la realización, el método, el objetivo, el objetivo del objeto) lanza {System.Println ("Aplicar una máscara facial antes de ir a la cama"); } @Override public void antes (método método, objeto [] args, objetivo de objeto) lanza lando {system.out.println ("sueño después de dormir"); }}1. AOP basado en agente
< id = "SleepHelperAdVisor"> <Property Name = "ACONISIÓN" REF = "SleepHelper"/> <Property Name = "PointCut" ref = "SlepPointCut"/> </Bean> <!-Definir un objeto proxy-> <bean id = "linaproxy"> <name de propiedad = "objetivo" ref = "lina"/> <name de propiedad = "valores de interceptornames" valor "valor" valor "singeSor" singeSor "/" singeSor " <!-<Property name = "proxyInterfaces" value = "com.tgb.springaop.service.sleeperable"/>-> </bean>
Como en el archivo de configuración:
El atributo de patrón especifica una expresión regular. Coincide con todos los métodos de sueño. Use org.springframework.aop.support.defaultPointCutAdvisor para combinar el punto tangente y la mejora para formar una tangente completa. Después de completar la configuración final, se genera un objeto proxy final a través de org.springframework.aop.framework.proxyFactoryBean.
2. Facetas de objetos Java puros y simples
¿Cómo decir que las facetas del objeto Java puramente simple? En mi opinión, es relativo a la primera configuración, que no requiere el uso de un proxy, sino que escanea automáticamente a través del mecanismo interno de la primavera. En este momento, nuestro archivo de configuración debe modificarse de la siguiente manera:
< <frijoles/>
¿Es mucho más simple que el primero? ¿No es necesario configurar el proxy?
3. @Spect Annotation Form
Según nuestra experiencia, también sabemos que la forma de anotaciones es más simple que el archivo de configuración. En este momento, debe comentar sobre los métodos o clases existentes:
/ ***Agregar mejora a través de la anotación*/ @Aspect @Component public class SleepHelper03 {/* @PointCut ("ejecutor (*com.tgb.springaop.service.impl ..*(..))")*/ @Pointcut ("ejecutor (***.sleep (..)") public void sleePoint () {{{{{} public void befefefefefefefefefefefe () {System.out.println ("Aplicar una máscara facial antes del sueño"); } @Afterreturning ("sleepoint ()") public void AfterSleep () {System.out.println ("Dream después de dormir"); }
Simplemente escriba en el archivo de configuración:
<
4. ASPCET Corte superficies en forma de inyección
Personalmente, siento que este es el más simple, más utilizado y más flexible. El archivo de configuración es el siguiente:
< </aop: aspecto> </aop: config>
La clase SleepHelper02 mencionada en el archivo de configuración es la siguiente:
/ *** Agregar mejora a través de anotaciones*/ public class SleepHelper02 {public void befefefefefefefefefeeLep () {System.out.println ("Aplicar una máscara facial antes de dormir"); } public void AfterSleep () {System.out.println ("Dream después de dormir"); }}
¿Se ve muy simple? ¿Todos usan Spring AOP? !
Con respecto a cómo llamar, escribí varias clases de prueba aquí. Puedes echarle un vistazo. Básicamente son los mismos:
/ *** Archivo de configuración Spring_aop.xml a través de proxy*/ @test public void test () {ApplicationContext ct = new ClassPathXMLApPlicationContext ("Spring_aop.xml"); Durmiente durmiente = (durmiente) ct.getBean ("linaproxy"); Sleeper.sleep (); } / *** Archivo de configuración Spring_aop_01.xml Respuesta corta Java Object* / @Test public void test01 () {ApplicationContext CT = new ClassPathXMLApPlicationContext ("Spring_AOP_01.XML"); Durmiente durmible = (durmiente) ct.getBean ("lina"); Sleeper.sleep (); } / *** Archivo de configuración Spring_AOP_03.xml anotado por aspecto* / @test public void test03 () {ApplicationContext CT = new ClassPathXMLApPlicationContext ("Spring_AOP_03.xml"); Durmiente durmible = (durmiente) ct.getBean ("lina"); Sleeper.sleep (); } / *** Archivo de configuración Spring_AOP_02.xml Archivo de configuración a través de APSECT* @Author Chen Lina* @Version 31 de mayo de 2015 a las 10:09:37 am* / @Test public Void test02 () {ApplicationContext CT = new ClassPathxMlaPPlicationContext ("treing_aop_02.xml"); Durmiente durmible = (durmiente) ct.getBean ("lina"); Sleeper.sleep (); }
De la clase de prueba, podemos ver que no importa de qué manera implementemos AOP, su uso no es diferente. Los resultados de estas clases de prueba son los mismos: