Este artículo presenta el método de usar AOP en el proyecto SpringBoot. Lo compartiré contigo. Los detalles son los siguientes:
1. Descripción general
El uso de la lógica general para implementar la tecnología AOP puede simplificar enormemente la redacción de programas, como la verificación de la firma, la autenticación, etc. Las transacciones declarativas de Spring también se implementan a través de la tecnología AOP.
Para un código específico, consulte el proyecto de ejemplo https://github.com/qihaiyan/springcamp/tree/master/spring-aop
La tecnología AOP de Spring tiene cuatro conceptos principales:
Pointcut: corte de punto, utilizado para definir qué método se interceptará, por ejemplo, ejecución (*cn.springcamp.springaop.service.*.*(..)))
Consejo: la acción que se ejecutará después de interceptar el método
Aspecto: corte, combine el punto de vista y los consejos juntos para formar una superficie cortada
Punto de unión: una instancia de PointCut durante la ejecución
Weaver: un marco para implementar AOP, como SuppectJ o Spring AOP
2. Definición Punto Definición
Las definiciones de PointCut de uso común incluyen ejecución y @Annotation. La ejecución define un método sin método y se utiliza para implementar una sección relativamente común. @Annotation se puede agregar como anotación a métodos específicos, como la anotación de transacciones de Spring.
La definición de corte de punto de ejecución debe colocarse en una clase pública para administrar centralmente la definición de corte de punto.
Ejemplo:
Clase pública CommonJoinPointConfig {@PointCut ("Ejecution (*cn.springcamp.springaop.service.*.*(..))") public void ServiceLayerExecution () {}}De esta manera, en la clase de aspecto específica, puede consultar el punto tangente a través de CommonJoinPointConfig.ServiceLayerExecution ().
public class BeforeAspect {@bebore ("CommonJoinPointConfig.ServiceLayerExecution ()") public Public antes (unión unión de unión) {System.out.println ("---------------> antes del aspecto"); System.out.println ("-----------------> antes de la ejecución de" + unión unión); }}Cuando el punto tangente debe cambiarse, solo necesita modificar la clase CommonJoinPointConfig, sin modificar cada clase de aspecto.
3. Corte de cara comúnmente usado
Antes: ejecute el consejo antes de ejecutar el método, que a menudo se usa para la verificación de firma, autenticación, etc.
Después de: ejecute después de que se complete la ejecución del método, ya sea que la ejecución sea exitosa o se lance la excepción.
After Returning: Ejecutar solo después de que la ejecución del método sea exitosa.
Afterthrowing: ejecutar solo después de una ejecución de método lanza una excepción.
Un aspecto simple:
@Aspecto @componentPublic class beforeAspect {@before ("CommonJOINPOINTCONFIG.ServiceLayerExecution ()") public void antes (unión unión unoint) {System.out.println ("---------------> antes del aspecto"); System.out.println ("----------------> antes de la ejecución de" + unión unión); }}4. Anotaciones personalizadas
Supongamos que queremos recopilar el tiempo de ejecución de un método específico, una manera más razonable es personalizar una anotación y luego agregar esta anotación al método que necesita recopilar el tiempo de ejecución.
Primero defina un tiempo de seguimiento de anotación:
@Target ({elementtype.method, elementtype.type}) @retention (retentionPolicy.runtime) public @Interface Tracktime {String Param () predeterminado ";}Luego, defina una clase de aspecto para implementar el comportamiento de la anotación:
@Aspecto@componentPublic Class TrackMeAspect {@aaround ("@Annotation (Tracktime)") Objeto público alrededor (procedimiento de unión unoinpoint, Tracktime TrackTime) lanza lando {objeto resultado = null; Long Starttime = System.CurrentTimemillis (); resultado = unkenpoint.proced (); Long Timetaken = System.CurrentTimemillis () - Starttime; System.out.println ("--------------> Tiempo tomado por" + unión de unión + "con Param [" + TrackTime.Param () + "] es" + Timetaken); resultado de retorno; }}Al usar esta anotación en un método, puede recopilar el tiempo de ejecución de este método:
@Tracktime (param = "myservice") public string runfoo () {system.out.println ("----------------> foo"); regresar "foo";}Tenga en cuenta que se puede aprobar la anotación @TrackTime (param = "myService").
Para que las anotaciones pasen los parámetros, debe especificar una cadena de parámetro parámetro () predeterminado "predeterminado" al definir anotaciones.
Al mismo tiempo, en la clase de aspecto, los parámetros correspondientes se agregan al método alrededor. El nombre de la variable del parámetro también se requiere para ser Tracktime en la anotación @around, pero no en el nombre de clase TrackTime.
@Around ("@Annotation (Tracktime)") Objeto público alrededor (procedimientojoinpoint unkenpoint, tracktime tracktime)5. Resumen
Al ejecutar el proyecto de muestra, la consola genera lo siguiente:
----------------> antes del aspecto
--------------> antes de la ejecución de la ejecución (String cn.springcamp.springaop.service.myservice.runfoo ())
---------------> foo
---------------> Tiempo tomado por ejecución (cadena cn.springcamp.springaop.service.myservice.runfoo ()) con param [myService] es 8
---------------> Después del aspecto
--------------> Después de la ejecución de la ejecución (String cn.springcamp.springaop.service.myservice.runfoo ())
---------------> después de retirar el aspecto
----------------> Ejecución (String cn.springcamp.springaop.service.myservice.runfoo ()) devuelto con valor foo
Se puede ver que la orden de ejecución de varios aspectos es antes después de la vuelta después de retirarse (después del lanzamiento)
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.