AOP现有两个主要的流行框架，即Spring AOP和Spring+AspectJ

代理

编译期间的静态织入，又称为编译时增强。织入（Weaving），指的是将切面代码和源业务代码链接起来的过程。AspectJ 就是这样一个面向切面的 Java 语言扩展，称呼其为语言的“扩展”，就是因为它扩展了 Java 语言的语法，需要特定的编译器来把 AspectJ 的代码编译成 JVM 可识别的 class 文件。
运行期间的动态代理，又称为运行时增强。这种方式是在程序运行时，依靠预先创建或运行时创建的代理类来完成切面功能的。比如 JDK 基于接口的动态代理技术，或 CGLib 基于类的代理对象生成技术就属于这一种。
动态代理的方式由于在运行时完成代理类或代理对象的创建，需要用到 Java 的拦截、反射和字节码生成等技术，因此运行时的性能表现往往没有静态织入好，功能也有较多限制，但是由于使用起来简便（不需要语言扩展，不需要特殊的编译器等），它的实际应用更为广泛。

CGLIB(Code Generation Library)是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB通过继承方式实现代理，在子类中采用方法拦截的技术拦截所有父类方法的调用并顺势织入横切逻辑。

1、JDK动态代理

利用拦截器(拦截器必须实现InvocationHanlder)加上反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。

例子：

package bean.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
interface Hello {
    public void toHelo(String str);
}
class HelloImpl implements Hello {
    public void toHelo(String str) {
        System.out.println("HelloImpl......"+str);
    }
}
class MyHandler implements InvocationHandler {
    //要代理的原始对象
    private Object obj;
    public MyHandler(Object obj) {
        super();
        this.obj = obj;
    }
    /**
    * 在代理实例上处理方法调用并返回结果
    * 
    * @param proxy 代理类
    * @param method 被代理的方法
    * @param args 该方法的参数数组
    */
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        before();
        Object result = method.invoke(obj, args);
        after();
        return result;
    }
    private void before() {
        System.out.println("before......");
    }
    private void after() {
        System.out.println("after......");
    }
}
public class ProxyDemo {
    public static void main(String[] args) {
        Hello hello = new HelloImpl();
        InvocationHandler invocaionHandler = new MyHandler(hello);
        Hello proxy = (Hello) Proxy.newProxyInstance(hello.getClass().getClassLoader(), hello.getClass().getInterfaces(), invocaionHandler);
        proxy.toHelo("proxy代理对象实现toHello方法");
    }
}

运行结果：

before......
HelloImpl......proxy代理对象实现toHello方法
after......

2、CGLiB动态代理

利用ASM开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

public class UserDao {
    public void save(){
        System.out.println("保存");
    }
    public void modify(){
        System.out.println("修改");
    }
    public void delete(){
        System.out.println("删除");
    }
}
/**
 * 创建CGLIB代理对象
 * 重写inttercept方法
 */
public class Cglib implements MethodInterceptor {
    /**
     *创建代理方法，生成CGLIB代理对象
     * target是目标对象，需要增强的对象
     * 返回目标对象的代理对象
     */
    public Object createProxy(Object target){
        //创建一个动态类对象，即增强类对象
        Enhancer enhancer = new Enhancer();
        //确定需要增强的类，设置为父类
        enhancer.setSuperclass(target.getClass());
        //确定代理逻辑对象为当前对象，要求当前对象实现MethodInterceptor方法
        enhancer.setCallback(this);
        //返回创建的代理对象
        return enhancer.create();
    }
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object o1 = methodProxy.invokeSuper(o,objects);
        after();
        return o1;
    }
    private void before() {
        System.out.println("before......");
    }
    private void after() {
        System.out.println("after......");
    }
}
public class App {
    public static void main( String[] args ) {
        //创建代理对象
        Cglib cglib = new Cglib();
        //创建目标对象
        UserDao userDao = new UserDao();
        //获取增强以后的目标对象
        UserDao DaoAdvice = (UserDao) cglib.createProxy(userDao);
        //测试
        DaoAdvice.save();
        System.out.println("-------------");
        DaoAdvice.delete();
        System.out.println("-------------");
        DaoAdvice.delete();
        System.out.println("-------------");
    }
}

3、何时使用JDK还是CGLiB？

1）如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP。 2）如果目标对象实现了接口，可以强制使用CGLIB实现AOP。 3）如果目标对象没有实现了接口，必须采用CGLIB库，Spring会自动在JDK动态代理和CGLIB之间转换。

4、如何强制使用CGLIB实现AOP？

1）添加CGLIB库(aspectjrt-xxx.jar、aspectjweaver-xxx.jar、cglib-nodep-xxx.jar) 2）在Spring配置文件中加入

5、JDK动态代理和CGLIB字节码生成的区别？

1）JDK动态代理只能对实现了接口的类生成代理，而不能针对类。利用拦截器(拦截器必须实现InvocationHanlder)加上反射机制生成一个实现代理接口的匿名**实现类**。 2）CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法，并覆盖其中方法实现增强，但是因为采用的是继承，所以该类或方法最好不要声明成final，对于final类或方法，是无法继承的。

1、JDK动态代理具体实现原理：
通过实现InvocationHandler接口创建自己的调用处理器；
通过为Proxy类指定ClassLoader对象和一组interface来创建动态代理；
通过反射机制获取动态代理类的构造函数，其唯一参数类型就是调用处理器接口类型；
通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数参入；
JDK动态代理是面向接口的代理模式，如果被代理目标没有接口那么Spring也无能为力，Spring通过Java的反射机制生产被代理接口的新的匿名实现类，重写了其中AOP的增强方法。
2、CGLib动态代理：
利用ASM开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。
3、两者对比：
JDK动态代理是面向接口的。
CGLib动态代理是通过字节码底层继承要代理类来实现，因此如果被代理类被final关键字所修饰，会失败。

作者：最终幻想_5b57
链接：https://www.jianshu.com/p/46d092bb737d
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

设计模式——静态代理

public interface UserService {
    //新增用户，为了简化不体现参数
    void addUser(); //接口方法不能体现{}，即body(类体)
    //修改用户，为了简化不体现参数
    void editUser();
}
public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("新增一个用户");
    }
    @Override
    public void editUser() {
        System.out.println("对用户进行修改");
    }
}
public class UserServiceProxy implements UserService{
    private UserService realSubject;
    @Override
    public void addUser() {
        System.out.println("代理类UserServiceProxy addUser方法的调用前执行...");
        realSubject.addUser();
        System.out.println("代理类UserServiceProxy addUser方法的调用后执行...");
    }
    @Override
    public void editUser() {
        System.out.println("代理类UserServiceProxy editUser方法的调用前执行...");
        realSubject.editUser();
        System.out.println("代理类UserServiceProxy editUser方法的调用后执行...");
    }
    public UserServiceProxy() {
    }
    public UserServiceProxy(UserService realSubject) {
        this.realSubject = realSubject;
    }
}
public class TestStaticProxy {
    @Test
    public void test(){
        UserService resultSubject = new UserServiceImpl();
        UserService proxy = new UserServiceProxy(resultSubject);
        proxy.addUser();
        proxy.editUser();
    }
}

JDK动态代理详解

public interface Hello {
    void sayHello();
}
public class HelloImpl implements Hello {
    @Override
    public void sayHello() {
        System.out.println("hello proxy!");
    }
}
public class MyInvocationHandler implements InvocationHandler {
    private Object target;
    public MyInvocationHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before");
        Object result = method.invoke(target, args);
        System.out.println("after");
        return result;
    }
}
public static void main(String[] args) {
    System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
    Hello hello = new HelloImpl();
    MyInvocationHandler handler = new MyInvocationHandler(hello);
    Hello o = (Hello)Proxy.newProxyInstance(hello.getClass().getClassLoader(), hello.getClass().getInterfaces(), handler);
    o.sayHello();
}

生成$Proxy0文件：

public final class $Proxy0 extends Proxy implements Hello {
    // 原来equals方法
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;
    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }
    public final boolean equals(Object var1) throws  {
        try {
            // 此处的h是Proxy类的{InvocationHandler h;}成员变量，在newProxy过程中，h即是MyInvocationHandler
            // invoke方法调用的实现即是MyInvocationHandler#invoke
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }
    public final void sayHello() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    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 int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("proxy.Hello").getMethod("sayHello");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

参考

【1】Spring中的拦截器与动态代理：https://mp.weixin.qq.com/s?src=11&timestamp=1633947376&ver=3368&signature=wMfzR6eXnLjq9ZCYkThjdIhSPK-grdi4NCkTSXs9cUjq*mvQXhGf9MsJr04y4l2ViAQ2QofzNwc3XL3cXoNveZTtKohLASqBG48yRw-DTOt7NrDFPAHgv9DEiRc3gW&new=1