Spring Framework in Depth (ii)--AOP face tangent

I. Overview of AOP

1, AOP: aspect-oriented programming, to achieve without adding code on the basis of adding some new functions (public functions);

2. AOP is not held by the spring framework, and spring is just one of the frameworks that supports AOP programming, which can be integrated with third-party frameworks for aspect-oriented programming (for example: Aspect);

3, the reality of the application scenario: the use of face-oriented programming, AOP framework has achieved a lot of facets-oriented content;

4. What programmers use AOP to do:

Write public functions, facets;

Based on the configuration of the AOP framework, the core business and the tangent plane are directly correlated;

5. There are three ways to implement AOP in spring:

Implementation based on the AspectJ annotation method

Schema-based XML configuration

Based on Proxyfactorybean agent implementation

Second, the simple implementation of AOP _ based on ASPECTJ annotations

The following steps are written:

1. Create a simple project that introduces a jar package:

　　

2, writing the core business interface and implementation class

 Public Interface Serviceinterface {    publicvoid  SayHello ();      Public void Saybye ();}

/** Core Focus, core business **/@Component ("Service") Public classServiceimplImplementsServiceinterface {@Override Public voidSayHello () {//TODO auto-generated Method StubSystem.out.println ("Say Hello"); }     Public voidSaybye () {System.out.println ("Say Bye"); }}

3, write a slice class: we simply do a printout

 /*   * Public Function: Facets *  */  @Component @aspect  public  Span style= "color: #0000ff;" >class   Advicemethod { //  pre-notification  //  This method is woven into the core business:  //  @Before, which means weaving before the core business;  // Span style= "color: #008000;" >execution, indicating where the weave is located  @Before ("point ()" )  public  void      befor () {System.out.println ( log 

4. Declare this class as a tangent in the core configuration file

<!--Enable annotations -<Context:annotation-config></Context:annotation-config><!--Scan -<Context:component-scanBase-package= "Service,advice"></Context:component-scan><!--enable configuration of AOP AspectJ -<Aop:aspectj-autoproxy></Aop:aspectj-autoproxy>

5. Finally create a new test class

 Public Static void Main (string[] args) {        new classpathxmlapplicationcontext ("Applicationcontext.xml");     // to use an interface to declare a core    business class // service is a proxy object    Serviceinterface service = (serviceinterface) ac.getbean ("service");     // SayHello code does not need to change, will automatically increase the function of the log     Service.sayhello ();    Service.saybye ();}

Note: The core business class must be declared here with an interface.

In this way, a simple AOP case is built;

Third, AOP detailed

By using a crosscutting technique, the interior of the encapsulated object is analyzed, and the behavior of multiple tired behaviors is encapsulated into a reusable module, which becomes aspect and tangent.

Separating the business logic in the application from the generic services it provides support for;

1. Common terminology in AOP

(1) Facets: Description of public function and cross function

(2) Notification: Classes that implement slice functionality

(3) Target object: Notified object, object of core focus

(4) Proxy object: Agent is the target object, through the proxy target object to increase the aspect function

Target object + Slice function

The first use of a proxy object is to implement slice functionality

(5) connection point: A static concept that represents the place of notification execution

(6) Entry point: The dynamic concept, the implementation of the notification when the implementation of the section function is, the connection point becomes a point of entry;

(7) Introduction: A static concept that associates facets with target objects

(8) Weaving: Applying facets to proxy objects is a process

2. Notification type

Pre-notification: Execution before core business execution

Notification after return: execution after core business returns

Exception notification: Execution of core business when an exception occurs

Post notification: Execution after core business execution

Surround notification: Execute when core tasks are executed

The code is written as follows: how to use annotations;

@Before ("Execution (* service.*.*.* ())") Public voidbefor () {System.out.println ("Front notification, log");} @After ("Execution (* service.*.*.* ())") Public voidAfter () {System.out.println ("Post notification, execution complete");} @AfterReturning ("Execution (* service.*.*.* ())") Public voidAfterreturn () {System.out.println ("Notify after return, get return value");} @AfterThrowing ("Execution (* service.*.*.* ())") Public voidThrowexp () {System.out.println ("Exception notification, when exception is executed");} @Around ("Execution (* service.*.*.* ())") PublicObject round (Proceedingjoinpoint PJP)throwsthrowable {System.out.println ("Surround the front ... "); Object o=pjp.proceed ();//normal execution of core businessSystem.out.println ("Surround ... "); returno;}

Execution Result:

　　　　

3. Annotations used in ASPECTJ

(1), ASPECTJ is a plane-oriented framework;

(2), spring through the ASPECTJ implementation of an annotated way to define the AOP-related configuration, reducing the dependency on the configuration file

(3), ASPECTJ provided by the note:

@AspectJ: Used on a class, declares that the class is a tangent plane;

@Before: Used on a method, declares the type of notification of the method;

@After: Used on a method, declares the type of notification of the method;

@AfterReturn: Used on a method, declares the type of notification of the method;

@AfterThrowing: Used on a method, declares the type of notification of the method;

@Around: Used on a method, declares the type of notification of the method;

@Pointcut: declaring entry points;

@Pointcut ("Execution (* service.*.*.* ())")publicvoid Point () {} @Before ( ) Publicvoid  befor () {    System.out.println ("Pre-notification, log");}

4. Use of execution expressions

AOP configuration, regardless of XML configuration, annotation configuration, used to define Pointcut pointcuts

Execution (* service.*.*.* (..))

　　　　

5. AOP case _ based on schema

Implementing AOP Slice classes with core configuration files

<!--AOP-based configuration items provided by the AspectJ -<Aop:config>    <Aop:pointcutexpression= "Execution (* service.*.*.* (..))"ID= "PointCut"/>    <Aop:aspectID= "Myaspect"ref= "Advicemethod_xml">        <Aop:beforeMethod= "Before"Pointcut-ref= "PointCut"/>        <Aop:afterMethod= "after"Pointcut-ref= "PointCut"/>        <aop:after-returningMethod= "Afterreturn"Pointcut-ref= "PointCut"/>        <aop:after-throwingMethod= "Throwexp"Pointcut-ref= "PointCut"/>        <Aop:aroundMethod= "Round"Pointcut-ref= "PointCut"/>    </Aop:aspect></Aop:config>

The implementation effect is the same as that based on annotations;

PS: Due to the limited ability of the author, such as Error please understand

Spring Framework in Depth (ii)--AOP face tangent