JDK动态代理简单基本原理

AOP面向切面编程的作用：在程序运行期间在不修改源代码的情况下增强方法，起到松耦合，减少代码的重复性的作用。

AOP的底层原理也就使用了动态代理技术

JDK动态代理实现方式: 代理对象<—JDK动态代理—目标接口<——目标对象

首先创建一个接口作为被增强对象实现的接口

public interface TargetInterface {
    // 被增强的方法1
    int save();
    // 被增强的方法2
    void delete();
}

再创建实现类

public class TargetImpl implements TargetInterface {
    public int save() {
        System.out.println("TargetImpl save....");
        return 100;
    }

    public void delete() {
        System.out.println("TargetImpl delete....");
    }
}

然后创建增强类，在里面定义增强用的方法

public class Advice {
    public void beforeMethod() {
        System.out.println("Advice beforeMethod");
    }

    public void afterMethod() {
        System.out.println("Advice afterMethod");
    }
}

然后再创建一个测试类,newTarget就是增强之后创建的增强对象

public class ProxyTest {
    public static void main(String[] args) {
        // 增强对象
        final Advice advice = new Advice();
        // 被增强的目标对象
        final TargetImpl target = new TargetImpl();
        // 被增强对象的类加载器
        ClassLoader classLoader = TargetImpl.class.getClassLoader();
        // 被增强对象实现的接口数组
        Class<?>[] interfaces = TargetImpl.class.getInterfaces();
        TargetInterface newTarget = (TargetInterface) Proxy.newProxyInstance(classLoader, interfaces, new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                // 如果执行的方法名叫delete则增强，反之不增强
                if (method.getName().equals("delete")) {
                    // 前置增强
                    advice.beforeMethod();
                    // 反射执行目标方法,获得方法的返回值
                    Object invoke = method.invoke(target, args);
                    // 后置增强
                    advice.afterMethod();
                    return invoke;
                }
                Object invoke = method.invoke(target, args);
                return invoke;
            }
        });
        newTarget.save();
        newTarget.delete();
    }
}

运行结果: 

 如果不加判断方法名，则自动会将所有执行的方法增强

运行结果:

 上面那个演示案例直接使用了匿名内部类invoke方法

下面实现InvocationHandler接口创建一个可以返回代理对象的类

public class AdviceObject implements InvocationHandler {
    // 声明目标类接口
    private TargetInterface target;
    public Object getAdviceObject(TargetInterface target) {
        this.target=target;
        // 类加载器
        ClassLoader targetInterfaceClassLoader = AdviceObject.class.getClassLoader();
        // 被代理对象实现的所有接口
        Class<?>[] interfaces = target.getClass().getInterfaces();
        // 执行增强并返回增强后的代理对象
        return Proxy.newProxyInstance(targetInterfaceClassLoader,interfaces,this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 声明切面
        Advice advice=new Advice();
        // 在被增强对象执行方法之前执行
        advice.beforeMethod();
        // 在目标类上调用方法并传入参数
        Object invoke = method.invoke(target, args);
        // 在被增强对象执行方法之后执行
        advice.afterMethod();
        // 返回被增强对象调用的方法的返回值
        return invoke;
    }
}

测试类:

public class ProxyTestDemo2 {
    public static void main(String[] args) {
        AdviceObject adviceObject = new AdviceObject();
        // 创建被代理的对象
        TargetInterface target = new TargetImpl();
        // 拿到代理对象(多态接收)
        TargetInterface newTarget = (TargetInterface) adviceObject.getAdviceObject(target);
        // 使用代理对象调用方法
        newTarget.save();
        newTarget.delete();
    }
}

运行结果: