AOP三种代理模式：静态代理、jdk、CGLIB

代理模式是常用的 Java 设计模式，代理类可以分为两种：
*静态代理：由程序员或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的 .class字节码 文件就已经存在。
*动态代理：在程序运行时，工具类会动态的生成代理类的 .class字节码 缓存在内存中，再运用反射机制，实例化出代理对象。动态代理有以下几种实现形式：JDK自带的动态代理（常用）、CGLIB（常用）、javaassist字节码操作库实现、ASM（底层使用指令，可维护性较差）。

静态代理

两种实现方式：
*基于接口的静态代理：只能针对有接口的类进行代理。
*基于继承的静态代理：无法对 static、final 类或方法进行代理。

基于接口的静态代理

public interface Person {
    void doSomeThing();
}

public class ChinesePerson implements Person {

    @Override
    public void doSomeThing() {
        System.out.println("ChinesePerson do some thing");
    }
}

public class InterfaceStaticProxy implements Person {

    private Person person;

    InterfaceStaticProxy(Person person){
        this.person = person;
    }

    @Override
    public void doSomeThing() {
        System.out.println("before interface static proxy");
        try{
            person.doSomeThing();
        }catch (Exception ex){
            System.out.println("ex: " + ex.getMessage());
            throw ex;
        } finally {
            System.out.println("after interface static proxy");
        }
    }
}

public class Client {
    public static void main(String ar[]){
        Person proxy = new InterfaceStaticProxy(new ChinesePerson());
        proxy.doSomeThing();
    }
}

//执行结果
before interface static proxy
ChinesePerson do some thing
after interface static proxy

基于继承的静态代理

public class ChinesePerson {
    public void doSomeThing() {
        System.out.println("ChinesePerson do some thing");
    }
}

public class InheritStaticProxy extends ChinesePerson {

    @Override
    public void doSomeThing() {
        System.out.println("before inherit static proxy");
        super.doSomeThing();
        System.out.println("after inherit static proxy");
    }
}

public class Client {
    public static void main(String ar[]){
        ChinesePerson person = new InheritStaticProxy();
        person.doSomeThing();
    }
}

//执行结果
before inherit static proxy
ChinesePerson do some thing
after inherit static proxy

动态代理

程序运行中，工具类会动态的生成代理类的 .class字节码 缓存在内存中，再运用反射机制，实例化出代理对象。实现方式是 jdk代理 和 cglib。

JDK代理

1.定义一个类 JdkProxy 实现接口 InvocationHandler。
2.在类 JdkProxy 的构造函数的入参中，传入类 ChinesePerson 的实例 chinesePerson。
3.在类 JdkProxy 的方法 invoke() 中使用 method.invoke(this.chinesePerson, args); 调用真实对象 chinesePerson 的方法，并在方法的 执行前、执行后、异常时 输出日志。

public interface Person {
    void doSomeThing();
}

public class ChinesePerson implements Person {

    @Override
    public void doSomeThing() {
        System.out.println("ChinesePerson do some thing");
    }
}

public class JdkProxy implements InvocationHandler {

    private ChinesePerson chinesePerson;

    JdkProxy(ChinesePerson chinesePerson){
        this.chinesePerson = chinesePerson;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before jdk dynamic proxy");
        Object result;
        try{
            result = method.invoke(this.chinesePerson,args);
        }catch (Exception ex){
            System.out.println("ex: " + ex.getMessage());
            throw ex;
        } finally {
            System.out.println("after jdk dynamic proxy");
        }
        return result;
    }
}

public class Client {
    public static void main(String ar[]){
        //创建动态代理类的实例
        Person proxy = (Person) Proxy.newProxyInstance(Client.class.getClassLoader(),new Class[]{Person.class},new JdkProxy(new ChinesePerson()));
        proxy.doSomeThing();
    }
}

//执行结果
before jdk dynamic proxy
ChinesePerson do some thing
after jdk dynamic proxy

CGLIB代理

1.定义一个类 CglibProxy 实现接口 MethodInterceptor。
2.在类 CglibProxy 的方法 intercept() 中使用 methodProxy.invokeSuper(o, objects); 调用父类 RealSubject 的方法，并在方法的 执行前、执行后、异常时 输出日志。

public class ChinesePerson {
    public void doSomeThing() {
        System.out.println("ChinesePerson do some thing");
    }
}

public class CglibProxy implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("before cglib dynamic proxy");
        Object result;
        try {
            result = methodProxy.invokeSuper(o, objects);
        } catch (Exception ex) {
            System.out.println("ex: " + ex.getMessage());
            throw ex;
        } finally {
            System.out.println("after cglib dynamic proxy");
        }
        return result;
    }
}

public class Client {
    public static void main(String ar[]){
        //创建一个类生成器 enhancer，设置其父类为 ChinesePerson.class，设置其回调函数为 new CglibProxy()。
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(ChinesePerson.class);
        enhancer.setCallback(new CglibProxy());

        // 创建动态代理类的实例 proxy，执行方法 doSomething() 。
        ChinesePerson proxy = (ChinesePerson) enhancer.create();
        proxy.doSomeThing();
    }
}

//执行结果
before cglib dynamic proxy
ChinesePerson do some thing
after cglib dynamic proxy