一、AOP介绍
AOP 全称Aspect Orient Programming，即面向切面编程，解决代码复用问题。是对OOP（Object Orient Programming）的一种补充。AOP实现的关键在于AOP框架自动创建的AOP代理，AOP代理分为静态代理和动态代理。
应该场景：广泛应用于处理一些具有横切性质的系统服务，如日志输出，安全控制，事务管理，缓存，对象池，异常处理等
1、静态代理：指使用AOP框架提供的命令进行编译，从而在编译阶段就生成AOP代理。也称编译时增强。
静态代理说白了，就是程序运行前就已经存在代理类的字节码文件、代理类和原始类的关系在运行前就已经确定了。
1) 静态代理Demo
IPerson接口
public interface IPerson {
//找工作
void findJob();
}
ZhangSan要去找工作
/**
* 目标对象
*/
public class ZhangSan implements IPerson {
@Override
public void findJob() {
System.out.println("我是张三，我在找工作...");
}
}
代理类：人才市场
public class PersonMarketProxy implements IPerson{
private IPerson target = new ZhangSan();
@Override
public void findJob() {
System.out.println("找工作前，请把简历给我");
target.findJob();
System.out.println("找到工作后，要好好工作");
}
}
测试
public class Main {
public static void main(String[] args) {
//代理对象
IPerson proxy = new PersonMarketProxy();
//代理对象执行代理方法
proxy.findJob();
}
}
静态代理虽然保证了业务。如果代理方法增多，势必每一个方法多要进行代理。除了实现类要实现这个方法，代理类也要实现这个方法。维护成本增加。
而动态代理很好的解决了这个问题。
2、动态代理：在运行时借助于JDK动态代理、CGLIG等内存中“临时”生成的AOP动态代理类。也称运行时增强。
动态代理Demo
2.1 IPerson接口
public interface IPerson {
//找工作
void findJob();
}
2.2 目标对象Zhangsan类
/**
* 目标对象
*/
public class ZhangSan implements IPerson {
@Override
public void findJob() {
System.out.println("我是张三，我在找工作...");
}
}
2.3 ProxyFactory 类
**
* 动态代理
* 给多个目标对象生成代理对象
*/
public class ProxyFactory {
//目标对象
private Object target;
public ProxyFactory(Object target){
this.target = target;
}
//返回代理对象
public Object getProxyObject(){
Object proxy = Proxy.newProxyInstance(
target.getClass().getClassLoader(), //目标对象类加载器
target.getClass().getInterfaces(), //目标对象实现的所有接口
new InvocationHandler() { //执行代理对象方法时候触发
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
Object result = null;
if("findJob".equals(methodName)){
System.out.println("找工作前，请把简历给我");
result = method.invoke(target, args);
System.out.println("找到工作后，要好好工作");
}else{
result = method.invoke(target, args);
}
return result;
}
});
return proxy;
}
}
2.4 测试
public class Main {
public static void main(String[] args) {
//目标对象
IPerson target = new ZhangSan();
System.out.println("目标对象:" + target.getClass());
//代理对象
IPerson proxy = (IPerson)new ProxyFactory(target).getProxyObject();
System.out.println("代理对象:" + proxy.getClass());
//代理对象执行代理方法
proxy.findJob();
createProxyClassFile(IPerson.class);
}
private static void createProxyClassFile(Class c){
byte[] data = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{c});
try{
FileOutputStream fileOutputStream = new FileOutputStream("$Proxy0.class");
fileOutputStream.write(data);
fileOutputStream.close();
}catch (FileNotFoundException e){
e.printStackTrace();
}catch (IOException e){
e.printStackTrace();
}
}
}
2.5 打印结果：
IPerson proxy = (IPerson)new ProxyFactory(target).getProxyObject();
这行代码其实是JDK动态生成了一个类去实现接口
public final class $Proxy0 extends Proxy implements IPerson
完整的代码如2.6.
2.6 然后使用使用createProxyClassFile，将代理类使用写入文件，文件的内容为
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import spring_springmvc.proxyDongTai.IPerson;
public final class $Proxy0 extends Proxy implements IPerson {
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final void findJob() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final int hashCode() throws {
try {
return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m3 = Class.forName("spring_springmvc.proxyDongTai.IPerson").getMethod("findJob", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
2.7 使用JDK生成动态代理的前提示目标类必须有实现的接口。 CGLIB是以动态生成的子类继承目标方式实现。在运行期动态的内存中构建一个子类
AOP是基于动态代理的
AOP是方法级别的
AOP可以分离业务和重复代码
二、实现AOP的技术
主要实现AOP思想的技术有AspectJ和Spring AOP
1、AspectJ的底层技术
AspectJ的底层技术是静态代理，即用一种AspectJ支持的特定语言编写切面，通过一个命令来编译，生成一个新的代理类。写着是编译时增强，相对于运行时增强性能更好。
2、Spring AOP
Spring AOP采用动态代理，在运行期间对业务方法进行增强，不会生成新类。Spring AOP提供了对JDK动态代理支持和CGLib的支持。
JDK动态代理只能为接口创建动态代理实例，而不能对类创建动态代理。需要获得被目标类的接口信息（使用反射技术），生成一个实现了代理接口的动态代理类（字节码），再通过反射机制获得动态代理的构造函数，利用构造函数生成代理类的实例对象，在调用具体方法前调用invokeHandler方法处理。
CGLib动态代理需要依赖asm包，把被代理对象类的class文件加载进来，修改其字节码生成子类。
但是Spring AOP基于注解配置的情况下，需要依赖于AspectJ包的标准注解，但是不需要额外的编译及AspectJ的织入器，而基于XML配置不需要。
Spring Aop过程
1、创建容器对象的时，根据切入点表达式拦截的类，生成代理对象
2、 如果有接口，使用JDK代理。反之，使用CGLIB代理。然后从容器中获取代理对象，在运行期间植入“切面” 类的方法。
如果目标类没有实现接口，且class为final， 则不能进行Spring AOP编程。
JDK动态代理和CGLib动态代理的区别
JDK动态代理需要接口，基于反射实现。(反射虚拟生成代理类)
CGLib动态代理需要子类实现。基于ASM字节码包装的一个类库。（基于ASM字节码技术虚拟生成代理类）