AOP: Aspect Oriented Programming 面向切面编程。
AOP底层实现原理：代理模式
什么是代理模式？
通过代理控制对象的访问,可以详细访问某个对象的方法，在这个方法调用处理，或调用后处理。既(AOP微实现) ,AOP核心技术面向切面编程。
代理模式分为静态代理与动态代理
静态代理：
什么是静态代理？
由程序员创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。
通过别的类B代理这个类A，这个类的具体情况，调用的类C并不知道
动态代理：
什么是动态代理？
1.代理对象,不需要实现接口
2.代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)
3.动态代理也叫做:JDK代理,接口代理
JDK动态代理：
实现方式：
1.通过实现InvocationHandler接口创建自己的调用处理器 IvocationHandler handler = new InvocationHandlerImpl(…);
2.通过为Proxy类指定ClassLoader对象和一组interface创建动态代理类Class clazz = Proxy.getProxyClass(classLoader,new Class[]{…});
3.通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});
4.通过构造函数创建代理类实例，此时需将调用处理器对象作为参数被传入Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));
需要被代理的类：
public interface Subject
{public void rent();public void hello(String str);
}
public class RealSubject implements Subject
{@Overridepublic void rent(){System.out.println("I want to rent my house");}@Overridepublic void hello(String str){System.out.println("hello: " + str);}
}动态代理类：
public class DynamicProxy implements InvocationHandler
{// 这个就是我们要代理的真实对象private Object subject;// 构造方法，给我们要代理的真实对象赋初值public DynamicProxy(Object subject){this.subject = subject;}@Overridepublic Object invoke(Object object, Method method, Object[] args)throws Throwable{// 在代理真实对象前我们可以添加一些自己的操作System.out.println("before rent house");System.out.println("Method:" + method);// 当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用method.invoke(subject, args);// 在代理真实对象后我们也可以添加一些自己的操作System.out.println("after rent house");return null;}
}
调用：
public static void main(String[] args){// 我们要代理的真实对象Subject realSubject = new RealSubject();// 我们要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法的InvocationHandler handler = new DynamicProxy(realSubject);/** 通过Proxy的newProxyInstance方法来创建我们的代理对象，我们来看看其三个参数* 第一个参数handler.getClass().getClassLoader()，我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象* 第二个参数realSubject.getClass().getInterfaces()，我们这里为代理对象提供的接口是真实对象所实行的接口，表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了* 第三个参数handler，我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上*/Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject.getClass().getInterfaces(), handler);System.out.println(subject.getClass().getName());subject.rent();subject.hello("world");}
结果：
$Proxy0before rent house
Method:public abstract void com.xiaoluo.dynamicproxy.Subject.rent()
I want to rent my house
after rent housebefore rent house
Method:public abstract void com.xiaoluo.dynamicproxy.Subject.hello(java.lang.String)
hello: world
after rent house总结：AOP主要是通过InvocationHandler(Interface)和 Proxy(Class）来实现
invoke是InvocationHandler的唯一方法
通过被代理的类，接口，以及我们实现的InvocationHandler作为参数，调用newProxyInstance
这样就把完成了代理
调用时通过invoke方法进行处理，我们可以在处理前后加上一些其他处理。
CGLIB动态代理：
public class CglibProxy implements MethodInterceptor {private Object targetObject;// 这里的目标类型为Object，则可以接受任意一种参数作为被代理类，实现了动态代理public Object getInstance(Object target) {// 设置需要创建子类的类this.targetObject = target;Enhancer enhancer = new Enhancer();enhancer.setSuperclass(target.getClass());enhancer.setCallback(this);return enhancer.create();}
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {System.out.println("开启事物");Object result = proxy.invoke(targetObject, args);System.out.println("关闭事物");// 返回代理对象return result;}public static void main(String[] args) {CglibProxy cglibProxy = new CglibProxy();UserDao userDao = (UserDao) cglibProxy.getInstance(new UserDao());userDao.save();}
}
java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。
而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。
编程中注解的AOP实现：
@Component
@Aspect
public class AopLog {
// 前置通知@Before("execution(* com.service.UserService.add(..))")public void begin() {System.out.println("前置通知");}
// 后置通知@After("execution(* com.service.UserService.add(..))")public void commit() {System.out.println("后置通知");}
// 运行通知@AfterReturning("execution(* com.service.UserService.add(..))")public void returning() {System.out.println("运行通知");}
// 异常通知@AfterThrowing("execution(* com.service.UserService.add(..))")public void afterThrowing() {System.out.println("异常通知");}
// 环绕通知@Around("execution(* com.service.UserService.add(..))")public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {System.out.println("环绕通知开始");proceedingJoinPoint.proceed();System.out.println("环绕通知结束");}
}
)
)