The AOP ( Aspect Oriented Programing), aspect-oriented programming , the AOP taken transverse extraction mechanism replacing the traditional longitudinal succession repetitive coding system (performance monitoring, transaction management, security check, a cache) the Spring the AOP pure Java implementation, no special type compilation process and loader at runtime woven into the code to enhance the target class through a proxy way AspecJ is a Java-based AOP framework, Spring2.0 start, Spring AOP support for the introduction of Aspect, AspectJ extends the Java language, provides a special the compiler provides lateral woven into the code at compile time
AOP terminology:
Connection point (Joinpoint): The so-called connection points are those points being intercepted. In Springthese points it refers to a method, because the Springonly support method type connection points.
Entry point (Pointcut): The so-called entry point refers to what we want to Joinpointdefine interception.
Notification / enhancement (Advice): The so-called notification means to intercept Joinpointafter the thing to do is to inform.
Pre-notification (Before advice): the target method before calling call notification method
After returning advice (After / finally advice): the target method after the completion of call notification method, the method does not care about anything at this time is output
Return notification (After returning advice): the target method after successful execution of call notification
Exception notification (After throwing advice): the target method after throwing an exception call notification
Around advice (Around advice): notification methods are wrapped in a notice, in the method to be notified before the call and after the call to perform custom behavior
Introduce / introduction (Introduction): introducing a special notification is, without modifying the premise class code, Introduction runtime class can be dynamically added or methods Field
Audience (Target): proxy target object
Weaving (Weaving): it refers to the enhancement applied to the target object to create a new proxy object processes. SpringDynamic proxy woven into, and AspectJthe use of compile-time weaving and weaving classes loaded in the period
Proxy (Proxy): a class is AOPthe knitted reinforcement, generates a proxy class Results
: Section (Aspect) binding and entry point notification (introducing) of
And in a plurality of connection points can function section (notification) woven into the execution of the program

The term AOP

AOP underlying principle
SpringThe AOPimplementation mechanisms are mainly two:
JDKDynamic Agent: The class that implements the interface generation agent
AOP: Organization definition .AOP Union is not defined by the Spring.
Spring in the notification :( enhanced Code)
Interface enhancements implemented before the target method execution, to be achieved: Front noticeorg.springframework.aop.MethodBeforeAdvice
Post Notification: Enhanced embodiment performed after the target method, the interface to be achieved,org.springframework.aop.AfterReturningAdvice
Around advice: before and after the target method embodiment Enhanced performed, the interface to be achieved,org.aopalliance.intercept.MethodInterceptor
An exception is thrown notice: After the implementation of enhanced method throws an exception, to implement an interface,org.springframework.aop.ThrowsAdvice
Introducing notice: Add some new methods and properties in the target class to implement an interface,org.springframework.aop.IntroductionInterceptor
For all methods of enhancing :( without a section cut point)
public class OrderDao {
public void add() {
System.out.println("添加订单");
}
public void delete() {
System.out.println("删除订单");
}
public void find() {
System.out.println("查询订单");
}
}
编写增强的类：
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
public class MyAroundAdvice implements MethodInterceptor{
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("执行方法之前增强.....");
Object result = invocation.proceed();
System.out.println("指向方法之后增强.....");
return result;
}
}
In Spring AOP, to use AspectJ pointcut expression language to define the cut-off point. About Spring AOP AspectJ cut-off point, the most important point is that Spring supports AspectJ only cut point indicator ( pointcut designator) is a subset. Spring is agent-based, and some cut point expression is independent of the proxy-based AOP. Spring AOP supported AspectJ tangential point indicator as follows:

When you try to use other indicators AspectJ in the Spring, will be thrown IllegalArgument-Exception exception. When we look at these Spring support as shown in the indicator, note that only the execution indicator is the practical implementation of matching, while other indicators are used to restrict the match. This indicates that execution is an indicator of our most important indicator used in the preparation of the cut point is defined. On this basis, we use other indicators to limit the matching cut-off point.

We use the
execution()
pointer to select
Performance
the
perform()
method. The method of expression to
“*”
start number, indicating that we do not care method returns the type of value. Then, we specify the fully qualified name of the class and method names. For the method parameter list, we use two dots
(..)
tables Mingqie point to choose any
perform()
method, regardless of the method to the Senate Yes.

public class ProductDao {
public int add(){
System.out.println("添加商品...");
int d = 10/0;
return 100;
}
public void update(){
System.out.println("修改商品...");
}
public void delete(){
System.out.println("删除商品...");
}
public void find(){
System.out.println("查询商品...");
}
}
第二步:定义切面
import org.aspectj.lang.ProceedingJoinPoint;
/**
* 切面类
* @author hao
*
*/
public class MyAspectXML {
public void before(){
System.out.println("前置通知...");
}
public void afterReturing(Object returnVal){
System.out.println("后置通知...返回值:"+returnVal);
}
public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
System.out.println("环绕前增强....");
Object result = proceedingJoinPoint.proceed();
System.out.println("环绕后增强....");
return result;
}
public void afterThrowing(Throwable e){
System.out.println("异常通知..."+e.getMessage());
}
public void after(){
System.out.println("最终通知....");
}
}
public class UserDao {
public void add(){
System.out.println("添加用户");
}
public int update(){
System.out.println("修改用户");
return 1;
}
public void delete(){
System.out.println("删除用户");
}
public void find(){
System.out.println("查询用户");
//int d = 1/ 0;
}
}
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
@EnableAspectJAutoProxy
@Configuration
public class MainConfigOfAOP {
//业务逻辑类加入容器中
@Bean
public UserDao userDao(){
return new UserDao();
}
//切面类加入到容器中
@Bean
public MyAspect myAspect(){
return new MyAspect();
}
}
In addition to the configuration class @EnableAspectJAutoProxy [open] annotation-based aop mode, in Spring many @EnableXXX (to take the time to sort out its principles);
to sum up
The business logic components and cut classes are added to the vessel; tell Spring which is cut class (@Aspect)
Each notification method in the class marked on the notification section annotation, Spring told when and where to run (pointcut expression)
Aop open annotation-based model; @EnableAspectJAutoProxy
AOP mechanism for realization of the principle of (AnnotationAwareAspectJAutoProxyCreator)
The underlying principle AnnotationAwareAspectJAutoProxyCreator
